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

package mock_shards

import (
	log "github.com/milvus-io/milvus/pkg/v2/log"
	message "github.com/milvus-io/milvus/pkg/v2/streaming/util/message"
	mock "github.com/stretchr/testify/mock"

	shards "github.com/milvus-io/milvus/internal/streamingnode/server/wal/interceptors/shard/shards"

	types "github.com/milvus-io/milvus/pkg/v2/streaming/util/types"

	utils "github.com/milvus-io/milvus/internal/streamingnode/server/wal/interceptors/shard/utils"
)

// MockShardManager is an autogenerated mock type for the ShardManager type
type MockShardManager struct {
	mock.Mock
}

type MockShardManager_Expecter struct {
	mock *mock.Mock
}

func (_m *MockShardManager) EXPECT() *MockShardManager_Expecter {
	return &MockShardManager_Expecter{mock: &_m.Mock}
}

// ApplyDelete provides a mock function with given fields: msg
func (_m *MockShardManager) ApplyDelete(msg message.MutableDeleteMessageV1) error {
	ret := _m.Called(msg)

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

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

	return r0
}

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

// ApplyDelete is a helper method to define mock.On call
//   - msg message.MutableDeleteMessageV1
func (_e *MockShardManager_Expecter) ApplyDelete(msg interface{}) *MockShardManager_ApplyDelete_Call {
	return &MockShardManager_ApplyDelete_Call{Call: _e.mock.On("ApplyDelete", msg)}
}

func (_c *MockShardManager_ApplyDelete_Call) Run(run func(msg message.MutableDeleteMessageV1)) *MockShardManager_ApplyDelete_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(message.MutableDeleteMessageV1))
	})
	return _c
}

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

func (_c *MockShardManager_ApplyDelete_Call) RunAndReturn(run func(message.MutableDeleteMessageV1) error) *MockShardManager_ApplyDelete_Call {
	_c.Call.Return(run)
	return _c
}

// AssignSegment provides a mock function with given fields: req
func (_m *MockShardManager) AssignSegment(req *shards.AssignSegmentRequest) (*shards.AssignSegmentResult, error) {
	ret := _m.Called(req)

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

	var r0 *shards.AssignSegmentResult
	var r1 error
	if rf, ok := ret.Get(0).(func(*shards.AssignSegmentRequest) (*shards.AssignSegmentResult, error)); ok {
		return rf(req)
	}
	if rf, ok := ret.Get(0).(func(*shards.AssignSegmentRequest) *shards.AssignSegmentResult); ok {
		r0 = rf(req)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*shards.AssignSegmentResult)
		}
	}

	if rf, ok := ret.Get(1).(func(*shards.AssignSegmentRequest) error); ok {
		r1 = rf(req)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// AssignSegment is a helper method to define mock.On call
//   - req *shards.AssignSegmentRequest
func (_e *MockShardManager_Expecter) AssignSegment(req interface{}) *MockShardManager_AssignSegment_Call {
	return &MockShardManager_AssignSegment_Call{Call: _e.mock.On("AssignSegment", req)}
}

func (_c *MockShardManager_AssignSegment_Call) Run(run func(req *shards.AssignSegmentRequest)) *MockShardManager_AssignSegment_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(*shards.AssignSegmentRequest))
	})
	return _c
}

func (_c *MockShardManager_AssignSegment_Call) Return(_a0 *shards.AssignSegmentResult, _a1 error) *MockShardManager_AssignSegment_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockShardManager_AssignSegment_Call) RunAndReturn(run func(*shards.AssignSegmentRequest) (*shards.AssignSegmentResult, error)) *MockShardManager_AssignSegment_Call {
	_c.Call.Return(run)
	return _c
}

// AsyncFlushSegment provides a mock function with given fields: signal
func (_m *MockShardManager) AsyncFlushSegment(signal utils.SealSegmentSignal) {
	_m.Called(signal)
}

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

// AsyncFlushSegment is a helper method to define mock.On call
//   - signal utils.SealSegmentSignal
func (_e *MockShardManager_Expecter) AsyncFlushSegment(signal interface{}) *MockShardManager_AsyncFlushSegment_Call {
	return &MockShardManager_AsyncFlushSegment_Call{Call: _e.mock.On("AsyncFlushSegment", signal)}
}

func (_c *MockShardManager_AsyncFlushSegment_Call) Run(run func(signal utils.SealSegmentSignal)) *MockShardManager_AsyncFlushSegment_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(utils.SealSegmentSignal))
	})
	return _c
}

func (_c *MockShardManager_AsyncFlushSegment_Call) Return() *MockShardManager_AsyncFlushSegment_Call {
	_c.Call.Return()
	return _c
}

func (_c *MockShardManager_AsyncFlushSegment_Call) RunAndReturn(run func(utils.SealSegmentSignal)) *MockShardManager_AsyncFlushSegment_Call {
	_c.Run(run)
	return _c
}

// Channel provides a mock function with no fields
func (_m *MockShardManager) Channel() types.PChannelInfo {
	ret := _m.Called()

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

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

	return r0
}

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

// Channel is a helper method to define mock.On call
func (_e *MockShardManager_Expecter) Channel() *MockShardManager_Channel_Call {
	return &MockShardManager_Channel_Call{Call: _e.mock.On("Channel")}
}

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

func (_c *MockShardManager_Channel_Call) Return(_a0 types.PChannelInfo) *MockShardManager_Channel_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockShardManager_Channel_Call) RunAndReturn(run func() types.PChannelInfo) *MockShardManager_Channel_Call {
	_c.Call.Return(run)
	return _c
}

// CheckIfCollectionCanBeCreated provides a mock function with given fields: collectionID
func (_m *MockShardManager) CheckIfCollectionCanBeCreated(collectionID int64) error {
	ret := _m.Called(collectionID)

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

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

	return r0
}

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

// CheckIfCollectionCanBeCreated is a helper method to define mock.On call
//   - collectionID int64
func (_e *MockShardManager_Expecter) CheckIfCollectionCanBeCreated(collectionID interface{}) *MockShardManager_CheckIfCollectionCanBeCreated_Call {
	return &MockShardManager_CheckIfCollectionCanBeCreated_Call{Call: _e.mock.On("CheckIfCollectionCanBeCreated", collectionID)}
}

func (_c *MockShardManager_CheckIfCollectionCanBeCreated_Call) Run(run func(collectionID int64)) *MockShardManager_CheckIfCollectionCanBeCreated_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(int64))
	})
	return _c
}

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

func (_c *MockShardManager_CheckIfCollectionCanBeCreated_Call) RunAndReturn(run func(int64) error) *MockShardManager_CheckIfCollectionCanBeCreated_Call {
	_c.Call.Return(run)
	return _c
}

// CheckIfCollectionExists provides a mock function with given fields: collectionID
func (_m *MockShardManager) CheckIfCollectionExists(collectionID int64) error {
	ret := _m.Called(collectionID)

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

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

	return r0
}

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

// CheckIfCollectionExists is a helper method to define mock.On call
//   - collectionID int64
func (_e *MockShardManager_Expecter) CheckIfCollectionExists(collectionID interface{}) *MockShardManager_CheckIfCollectionExists_Call {
	return &MockShardManager_CheckIfCollectionExists_Call{Call: _e.mock.On("CheckIfCollectionExists", collectionID)}
}

func (_c *MockShardManager_CheckIfCollectionExists_Call) Run(run func(collectionID int64)) *MockShardManager_CheckIfCollectionExists_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(int64))
	})
	return _c
}

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

func (_c *MockShardManager_CheckIfCollectionExists_Call) RunAndReturn(run func(int64) error) *MockShardManager_CheckIfCollectionExists_Call {
	_c.Call.Return(run)
	return _c
}

// CheckIfPartitionCanBeCreated provides a mock function with given fields: uniquePartitionKey
func (_m *MockShardManager) CheckIfPartitionCanBeCreated(uniquePartitionKey shards.PartitionUniqueKey) error {
	ret := _m.Called(uniquePartitionKey)

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

	var r0 error
	if rf, ok := ret.Get(0).(func(shards.PartitionUniqueKey) error); ok {
		r0 = rf(uniquePartitionKey)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

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

// CheckIfPartitionCanBeCreated is a helper method to define mock.On call
//   - uniquePartitionKey shards.PartitionUniqueKey
func (_e *MockShardManager_Expecter) CheckIfPartitionCanBeCreated(uniquePartitionKey interface{}) *MockShardManager_CheckIfPartitionCanBeCreated_Call {
	return &MockShardManager_CheckIfPartitionCanBeCreated_Call{Call: _e.mock.On("CheckIfPartitionCanBeCreated", uniquePartitionKey)}
}

func (_c *MockShardManager_CheckIfPartitionCanBeCreated_Call) Run(run func(uniquePartitionKey shards.PartitionUniqueKey)) *MockShardManager_CheckIfPartitionCanBeCreated_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(shards.PartitionUniqueKey))
	})
	return _c
}

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

func (_c *MockShardManager_CheckIfPartitionCanBeCreated_Call) RunAndReturn(run func(shards.PartitionUniqueKey) error) *MockShardManager_CheckIfPartitionCanBeCreated_Call {
	_c.Call.Return(run)
	return _c
}

// CheckIfPartitionExists provides a mock function with given fields: uniquePartitionKey
func (_m *MockShardManager) CheckIfPartitionExists(uniquePartitionKey shards.PartitionUniqueKey) error {
	ret := _m.Called(uniquePartitionKey)

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

	var r0 error
	if rf, ok := ret.Get(0).(func(shards.PartitionUniqueKey) error); ok {
		r0 = rf(uniquePartitionKey)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

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

// CheckIfPartitionExists is a helper method to define mock.On call
//   - uniquePartitionKey shards.PartitionUniqueKey
func (_e *MockShardManager_Expecter) CheckIfPartitionExists(uniquePartitionKey interface{}) *MockShardManager_CheckIfPartitionExists_Call {
	return &MockShardManager_CheckIfPartitionExists_Call{Call: _e.mock.On("CheckIfPartitionExists", uniquePartitionKey)}
}

func (_c *MockShardManager_CheckIfPartitionExists_Call) Run(run func(uniquePartitionKey shards.PartitionUniqueKey)) *MockShardManager_CheckIfPartitionExists_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(shards.PartitionUniqueKey))
	})
	return _c
}

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

func (_c *MockShardManager_CheckIfPartitionExists_Call) RunAndReturn(run func(shards.PartitionUniqueKey) error) *MockShardManager_CheckIfPartitionExists_Call {
	_c.Call.Return(run)
	return _c
}

// CheckIfSegmentCanBeCreated provides a mock function with given fields: uniquePartitionKey, segmentID
func (_m *MockShardManager) CheckIfSegmentCanBeCreated(uniquePartitionKey shards.PartitionUniqueKey, segmentID int64) error {
	ret := _m.Called(uniquePartitionKey, segmentID)

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

	var r0 error
	if rf, ok := ret.Get(0).(func(shards.PartitionUniqueKey, int64) error); ok {
		r0 = rf(uniquePartitionKey, segmentID)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

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

// CheckIfSegmentCanBeCreated is a helper method to define mock.On call
//   - uniquePartitionKey shards.PartitionUniqueKey
//   - segmentID int64
func (_e *MockShardManager_Expecter) CheckIfSegmentCanBeCreated(uniquePartitionKey interface{}, segmentID interface{}) *MockShardManager_CheckIfSegmentCanBeCreated_Call {
	return &MockShardManager_CheckIfSegmentCanBeCreated_Call{Call: _e.mock.On("CheckIfSegmentCanBeCreated", uniquePartitionKey, segmentID)}
}

func (_c *MockShardManager_CheckIfSegmentCanBeCreated_Call) Run(run func(uniquePartitionKey shards.PartitionUniqueKey, segmentID int64)) *MockShardManager_CheckIfSegmentCanBeCreated_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(shards.PartitionUniqueKey), args[1].(int64))
	})
	return _c
}

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

func (_c *MockShardManager_CheckIfSegmentCanBeCreated_Call) RunAndReturn(run func(shards.PartitionUniqueKey, int64) error) *MockShardManager_CheckIfSegmentCanBeCreated_Call {
	_c.Call.Return(run)
	return _c
}

// CheckIfSegmentCanBeFlushed provides a mock function with given fields: uniquePartitionKey, segmentID
func (_m *MockShardManager) CheckIfSegmentCanBeFlushed(uniquePartitionKey shards.PartitionUniqueKey, segmentID int64) error {
	ret := _m.Called(uniquePartitionKey, segmentID)

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

	var r0 error
	if rf, ok := ret.Get(0).(func(shards.PartitionUniqueKey, int64) error); ok {
		r0 = rf(uniquePartitionKey, segmentID)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

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

// CheckIfSegmentCanBeFlushed is a helper method to define mock.On call
//   - uniquePartitionKey shards.PartitionUniqueKey
//   - segmentID int64
func (_e *MockShardManager_Expecter) CheckIfSegmentCanBeFlushed(uniquePartitionKey interface{}, segmentID interface{}) *MockShardManager_CheckIfSegmentCanBeFlushed_Call {
	return &MockShardManager_CheckIfSegmentCanBeFlushed_Call{Call: _e.mock.On("CheckIfSegmentCanBeFlushed", uniquePartitionKey, segmentID)}
}

func (_c *MockShardManager_CheckIfSegmentCanBeFlushed_Call) Run(run func(uniquePartitionKey shards.PartitionUniqueKey, segmentID int64)) *MockShardManager_CheckIfSegmentCanBeFlushed_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(shards.PartitionUniqueKey), args[1].(int64))
	})
	return _c
}

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

func (_c *MockShardManager_CheckIfSegmentCanBeFlushed_Call) RunAndReturn(run func(shards.PartitionUniqueKey, int64) error) *MockShardManager_CheckIfSegmentCanBeFlushed_Call {
	_c.Call.Return(run)
	return _c
}

// Close provides a mock function with no fields
func (_m *MockShardManager) Close() {
	_m.Called()
}

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

// Close is a helper method to define mock.On call
func (_e *MockShardManager_Expecter) Close() *MockShardManager_Close_Call {
	return &MockShardManager_Close_Call{Call: _e.mock.On("Close")}
}

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

func (_c *MockShardManager_Close_Call) Return() *MockShardManager_Close_Call {
	_c.Call.Return()
	return _c
}

func (_c *MockShardManager_Close_Call) RunAndReturn(run func()) *MockShardManager_Close_Call {
	_c.Run(run)
	return _c
}

// CreateCollection provides a mock function with given fields: msg
func (_m *MockShardManager) CreateCollection(msg message.ImmutableCreateCollectionMessageV1) {
	_m.Called(msg)
}

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

// CreateCollection is a helper method to define mock.On call
//   - msg message.ImmutableCreateCollectionMessageV1
func (_e *MockShardManager_Expecter) CreateCollection(msg interface{}) *MockShardManager_CreateCollection_Call {
	return &MockShardManager_CreateCollection_Call{Call: _e.mock.On("CreateCollection", msg)}
}

func (_c *MockShardManager_CreateCollection_Call) Run(run func(msg message.ImmutableCreateCollectionMessageV1)) *MockShardManager_CreateCollection_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(message.ImmutableCreateCollectionMessageV1))
	})
	return _c
}

func (_c *MockShardManager_CreateCollection_Call) Return() *MockShardManager_CreateCollection_Call {
	_c.Call.Return()
	return _c
}

func (_c *MockShardManager_CreateCollection_Call) RunAndReturn(run func(message.ImmutableCreateCollectionMessageV1)) *MockShardManager_CreateCollection_Call {
	_c.Run(run)
	return _c
}

// CreatePartition provides a mock function with given fields: msg
func (_m *MockShardManager) CreatePartition(msg message.ImmutableCreatePartitionMessageV1) {
	_m.Called(msg)
}

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

// CreatePartition is a helper method to define mock.On call
//   - msg message.ImmutableCreatePartitionMessageV1
func (_e *MockShardManager_Expecter) CreatePartition(msg interface{}) *MockShardManager_CreatePartition_Call {
	return &MockShardManager_CreatePartition_Call{Call: _e.mock.On("CreatePartition", msg)}
}

func (_c *MockShardManager_CreatePartition_Call) Run(run func(msg message.ImmutableCreatePartitionMessageV1)) *MockShardManager_CreatePartition_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(message.ImmutableCreatePartitionMessageV1))
	})
	return _c
}

func (_c *MockShardManager_CreatePartition_Call) Return() *MockShardManager_CreatePartition_Call {
	_c.Call.Return()
	return _c
}

func (_c *MockShardManager_CreatePartition_Call) RunAndReturn(run func(message.ImmutableCreatePartitionMessageV1)) *MockShardManager_CreatePartition_Call {
	_c.Run(run)
	return _c
}

// CreateSegment provides a mock function with given fields: msg
func (_m *MockShardManager) CreateSegment(msg message.ImmutableCreateSegmentMessageV2) {
	_m.Called(msg)
}

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

// CreateSegment is a helper method to define mock.On call
//   - msg message.ImmutableCreateSegmentMessageV2
func (_e *MockShardManager_Expecter) CreateSegment(msg interface{}) *MockShardManager_CreateSegment_Call {
	return &MockShardManager_CreateSegment_Call{Call: _e.mock.On("CreateSegment", msg)}
}

func (_c *MockShardManager_CreateSegment_Call) Run(run func(msg message.ImmutableCreateSegmentMessageV2)) *MockShardManager_CreateSegment_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(message.ImmutableCreateSegmentMessageV2))
	})
	return _c
}

func (_c *MockShardManager_CreateSegment_Call) Return() *MockShardManager_CreateSegment_Call {
	_c.Call.Return()
	return _c
}

func (_c *MockShardManager_CreateSegment_Call) RunAndReturn(run func(message.ImmutableCreateSegmentMessageV2)) *MockShardManager_CreateSegment_Call {
	_c.Run(run)
	return _c
}

// DropCollection provides a mock function with given fields: msg
func (_m *MockShardManager) DropCollection(msg message.ImmutableDropCollectionMessageV1) {
	_m.Called(msg)
}

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

// DropCollection is a helper method to define mock.On call
//   - msg message.ImmutableDropCollectionMessageV1
func (_e *MockShardManager_Expecter) DropCollection(msg interface{}) *MockShardManager_DropCollection_Call {
	return &MockShardManager_DropCollection_Call{Call: _e.mock.On("DropCollection", msg)}
}

func (_c *MockShardManager_DropCollection_Call) Run(run func(msg message.ImmutableDropCollectionMessageV1)) *MockShardManager_DropCollection_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(message.ImmutableDropCollectionMessageV1))
	})
	return _c
}

func (_c *MockShardManager_DropCollection_Call) Return() *MockShardManager_DropCollection_Call {
	_c.Call.Return()
	return _c
}

func (_c *MockShardManager_DropCollection_Call) RunAndReturn(run func(message.ImmutableDropCollectionMessageV1)) *MockShardManager_DropCollection_Call {
	_c.Run(run)
	return _c
}

// DropPartition provides a mock function with given fields: msg
func (_m *MockShardManager) DropPartition(msg message.ImmutableDropPartitionMessageV1) {
	_m.Called(msg)
}

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

// DropPartition is a helper method to define mock.On call
//   - msg message.ImmutableDropPartitionMessageV1
func (_e *MockShardManager_Expecter) DropPartition(msg interface{}) *MockShardManager_DropPartition_Call {
	return &MockShardManager_DropPartition_Call{Call: _e.mock.On("DropPartition", msg)}
}

func (_c *MockShardManager_DropPartition_Call) Run(run func(msg message.ImmutableDropPartitionMessageV1)) *MockShardManager_DropPartition_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(message.ImmutableDropPartitionMessageV1))
	})
	return _c
}

func (_c *MockShardManager_DropPartition_Call) Return() *MockShardManager_DropPartition_Call {
	_c.Call.Return()
	return _c
}

func (_c *MockShardManager_DropPartition_Call) RunAndReturn(run func(message.ImmutableDropPartitionMessageV1)) *MockShardManager_DropPartition_Call {
	_c.Run(run)
	return _c
}

// FlushAllAndFenceSegmentAllocUntil provides a mock function with given fields: timetick
func (_m *MockShardManager) FlushAllAndFenceSegmentAllocUntil(timetick uint64) ([]int64, error) {
	ret := _m.Called(timetick)

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

	var r0 []int64
	var r1 error
	if rf, ok := ret.Get(0).(func(uint64) ([]int64, error)); ok {
		return rf(timetick)
	}
	if rf, ok := ret.Get(0).(func(uint64) []int64); ok {
		r0 = rf(timetick)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]int64)
		}
	}

	if rf, ok := ret.Get(1).(func(uint64) error); ok {
		r1 = rf(timetick)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// FlushAllAndFenceSegmentAllocUntil is a helper method to define mock.On call
//   - timetick uint64
func (_e *MockShardManager_Expecter) FlushAllAndFenceSegmentAllocUntil(timetick interface{}) *MockShardManager_FlushAllAndFenceSegmentAllocUntil_Call {
	return &MockShardManager_FlushAllAndFenceSegmentAllocUntil_Call{Call: _e.mock.On("FlushAllAndFenceSegmentAllocUntil", timetick)}
}

func (_c *MockShardManager_FlushAllAndFenceSegmentAllocUntil_Call) Run(run func(timetick uint64)) *MockShardManager_FlushAllAndFenceSegmentAllocUntil_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(uint64))
	})
	return _c
}

func (_c *MockShardManager_FlushAllAndFenceSegmentAllocUntil_Call) Return(_a0 []int64, _a1 error) *MockShardManager_FlushAllAndFenceSegmentAllocUntil_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockShardManager_FlushAllAndFenceSegmentAllocUntil_Call) RunAndReturn(run func(uint64) ([]int64, error)) *MockShardManager_FlushAllAndFenceSegmentAllocUntil_Call {
	_c.Call.Return(run)
	return _c
}

// FlushAndFenceSegmentAllocUntil provides a mock function with given fields: collectionID, timetick
func (_m *MockShardManager) FlushAndFenceSegmentAllocUntil(collectionID int64, timetick uint64) ([]int64, error) {
	ret := _m.Called(collectionID, timetick)

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

	var r0 []int64
	var r1 error
	if rf, ok := ret.Get(0).(func(int64, uint64) ([]int64, error)); ok {
		return rf(collectionID, timetick)
	}
	if rf, ok := ret.Get(0).(func(int64, uint64) []int64); ok {
		r0 = rf(collectionID, timetick)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]int64)
		}
	}

	if rf, ok := ret.Get(1).(func(int64, uint64) error); ok {
		r1 = rf(collectionID, timetick)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// FlushAndFenceSegmentAllocUntil is a helper method to define mock.On call
//   - collectionID int64
//   - timetick uint64
func (_e *MockShardManager_Expecter) FlushAndFenceSegmentAllocUntil(collectionID interface{}, timetick interface{}) *MockShardManager_FlushAndFenceSegmentAllocUntil_Call {
	return &MockShardManager_FlushAndFenceSegmentAllocUntil_Call{Call: _e.mock.On("FlushAndFenceSegmentAllocUntil", collectionID, timetick)}
}

func (_c *MockShardManager_FlushAndFenceSegmentAllocUntil_Call) Run(run func(collectionID int64, timetick uint64)) *MockShardManager_FlushAndFenceSegmentAllocUntil_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(int64), args[1].(uint64))
	})
	return _c
}

func (_c *MockShardManager_FlushAndFenceSegmentAllocUntil_Call) Return(_a0 []int64, _a1 error) *MockShardManager_FlushAndFenceSegmentAllocUntil_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockShardManager_FlushAndFenceSegmentAllocUntil_Call) RunAndReturn(run func(int64, uint64) ([]int64, error)) *MockShardManager_FlushAndFenceSegmentAllocUntil_Call {
	_c.Call.Return(run)
	return _c
}

// FlushSegment provides a mock function with given fields: msg
func (_m *MockShardManager) FlushSegment(msg message.ImmutableFlushMessageV2) {
	_m.Called(msg)
}

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

// FlushSegment is a helper method to define mock.On call
//   - msg message.ImmutableFlushMessageV2
func (_e *MockShardManager_Expecter) FlushSegment(msg interface{}) *MockShardManager_FlushSegment_Call {
	return &MockShardManager_FlushSegment_Call{Call: _e.mock.On("FlushSegment", msg)}
}

func (_c *MockShardManager_FlushSegment_Call) Run(run func(msg message.ImmutableFlushMessageV2)) *MockShardManager_FlushSegment_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(message.ImmutableFlushMessageV2))
	})
	return _c
}

func (_c *MockShardManager_FlushSegment_Call) Return() *MockShardManager_FlushSegment_Call {
	_c.Call.Return()
	return _c
}

func (_c *MockShardManager_FlushSegment_Call) RunAndReturn(run func(message.ImmutableFlushMessageV2)) *MockShardManager_FlushSegment_Call {
	_c.Run(run)
	return _c
}

// Logger provides a mock function with no fields
func (_m *MockShardManager) Logger() *log.MLogger {
	ret := _m.Called()

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

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

	return r0
}

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

// Logger is a helper method to define mock.On call
func (_e *MockShardManager_Expecter) Logger() *MockShardManager_Logger_Call {
	return &MockShardManager_Logger_Call{Call: _e.mock.On("Logger")}
}

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

func (_c *MockShardManager_Logger_Call) Return(_a0 *log.MLogger) *MockShardManager_Logger_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockShardManager_Logger_Call) RunAndReturn(run func() *log.MLogger) *MockShardManager_Logger_Call {
	_c.Call.Return(run)
	return _c
}

// WaitUntilGrowingSegmentReady provides a mock function with given fields: uniquePartitionKey
func (_m *MockShardManager) WaitUntilGrowingSegmentReady(uniquePartitionKey shards.PartitionUniqueKey) (<-chan struct{}, error) {
	ret := _m.Called(uniquePartitionKey)

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

	var r0 <-chan struct{}
	var r1 error
	if rf, ok := ret.Get(0).(func(shards.PartitionUniqueKey) (<-chan struct{}, error)); ok {
		return rf(uniquePartitionKey)
	}
	if rf, ok := ret.Get(0).(func(shards.PartitionUniqueKey) <-chan struct{}); ok {
		r0 = rf(uniquePartitionKey)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(<-chan struct{})
		}
	}

	if rf, ok := ret.Get(1).(func(shards.PartitionUniqueKey) error); ok {
		r1 = rf(uniquePartitionKey)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// WaitUntilGrowingSegmentReady is a helper method to define mock.On call
//   - uniquePartitionKey shards.PartitionUniqueKey
func (_e *MockShardManager_Expecter) WaitUntilGrowingSegmentReady(uniquePartitionKey interface{}) *MockShardManager_WaitUntilGrowingSegmentReady_Call {
	return &MockShardManager_WaitUntilGrowingSegmentReady_Call{Call: _e.mock.On("WaitUntilGrowingSegmentReady", uniquePartitionKey)}
}

func (_c *MockShardManager_WaitUntilGrowingSegmentReady_Call) Run(run func(uniquePartitionKey shards.PartitionUniqueKey)) *MockShardManager_WaitUntilGrowingSegmentReady_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(shards.PartitionUniqueKey))
	})
	return _c
}

func (_c *MockShardManager_WaitUntilGrowingSegmentReady_Call) Return(_a0 <-chan struct{}, _a1 error) *MockShardManager_WaitUntilGrowingSegmentReady_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockShardManager_WaitUntilGrowingSegmentReady_Call) RunAndReturn(run func(shards.PartitionUniqueKey) (<-chan struct{}, error)) *MockShardManager_WaitUntilGrowingSegmentReady_Call {
	_c.Call.Return(run)
	return _c
}

// NewMockShardManager creates a new instance of MockShardManager. 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 NewMockShardManager(t interface {
	mock.TestingT
	Cleanup(func())
}) *MockShardManager {
	mock := &MockShardManager{}
	mock.Mock.Test(t)

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

	return mock
}
