// Code generated by mockery. DO NOT EDIT.

package mock_chatsubscription

import (
	chatmodel "github.com/anyproto/anytype-heart/core/block/chats/chatmodel"

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

	model "github.com/anyproto/anytype-heart/pkg/lib/pb/model"

	session "github.com/anyproto/anytype-heart/core/session"
)

// MockManager is an autogenerated mock type for the Manager type
type MockManager struct {
	mock.Mock
}

type MockManager_Expecter struct {
	mock *mock.Mock
}

func (_m *MockManager) EXPECT() *MockManager_Expecter {
	return &MockManager_Expecter{mock: &_m.Mock}
}

// Add provides a mock function with given fields: prevOrderId, message
func (_m *MockManager) Add(prevOrderId string, message *chatmodel.Message) {
	_m.Called(prevOrderId, message)
}

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

// Add is a helper method to define mock.On call
//   - prevOrderId string
//   - message *chatmodel.Message
func (_e *MockManager_Expecter) Add(prevOrderId interface{}, message interface{}) *MockManager_Add_Call {
	return &MockManager_Add_Call{Call: _e.mock.On("Add", prevOrderId, message)}
}

func (_c *MockManager_Add_Call) Run(run func(prevOrderId string, message *chatmodel.Message)) *MockManager_Add_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(string), args[1].(*chatmodel.Message))
	})
	return _c
}

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

func (_c *MockManager_Add_Call) RunAndReturn(run func(string, *chatmodel.Message)) *MockManager_Add_Call {
	_c.Call.Return(run)
	return _c
}

// Delete provides a mock function with given fields: messageId
func (_m *MockManager) Delete(messageId string) {
	_m.Called(messageId)
}

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

// Delete is a helper method to define mock.On call
//   - messageId string
func (_e *MockManager_Expecter) Delete(messageId interface{}) *MockManager_Delete_Call {
	return &MockManager_Delete_Call{Call: _e.mock.On("Delete", messageId)}
}

func (_c *MockManager_Delete_Call) Run(run func(messageId string)) *MockManager_Delete_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(string))
	})
	return _c
}

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

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

// Flush provides a mock function with given fields:
func (_m *MockManager) Flush() {
	_m.Called()
}

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

// Flush is a helper method to define mock.On call
func (_e *MockManager_Expecter) Flush() *MockManager_Flush_Call {
	return &MockManager_Flush_Call{Call: _e.mock.On("Flush")}
}

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

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

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

// ForceSendingChatState provides a mock function with given fields:
func (_m *MockManager) ForceSendingChatState() {
	_m.Called()
}

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

// ForceSendingChatState is a helper method to define mock.On call
func (_e *MockManager_Expecter) ForceSendingChatState() *MockManager_ForceSendingChatState_Call {
	return &MockManager_ForceSendingChatState_Call{Call: _e.mock.On("ForceSendingChatState")}
}

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

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

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

// GetChatState provides a mock function with given fields:
func (_m *MockManager) GetChatState() *model.ChatState {
	ret := _m.Called()

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

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

	return r0
}

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

// GetChatState is a helper method to define mock.On call
func (_e *MockManager_Expecter) GetChatState() *MockManager_GetChatState_Call {
	return &MockManager_GetChatState_Call{Call: _e.mock.On("GetChatState")}
}

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

func (_c *MockManager_GetChatState_Call) Return(_a0 *model.ChatState) *MockManager_GetChatState_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockManager_GetChatState_Call) RunAndReturn(run func() *model.ChatState) *MockManager_GetChatState_Call {
	_c.Call.Return(run)
	return _c
}

// IsActive provides a mock function with given fields:
func (_m *MockManager) IsActive() bool {
	ret := _m.Called()

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

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

	return r0
}

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

// IsActive is a helper method to define mock.On call
func (_e *MockManager_Expecter) IsActive() *MockManager_IsActive_Call {
	return &MockManager_IsActive_Call{Call: _e.mock.On("IsActive")}
}

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

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

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

// Lock provides a mock function with given fields:
func (_m *MockManager) Lock() {
	_m.Called()
}

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

// Lock is a helper method to define mock.On call
func (_e *MockManager_Expecter) Lock() *MockManager_Lock_Call {
	return &MockManager_Lock_Call{Call: _e.mock.On("Lock")}
}

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

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

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

// ReadMessages provides a mock function with given fields: newOldestOrderId, idsModified, counterType
func (_m *MockManager) ReadMessages(newOldestOrderId string, idsModified []string, counterType chatmodel.CounterType) {
	_m.Called(newOldestOrderId, idsModified, counterType)
}

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

// ReadMessages is a helper method to define mock.On call
//   - newOldestOrderId string
//   - idsModified []string
//   - counterType chatmodel.CounterType
func (_e *MockManager_Expecter) ReadMessages(newOldestOrderId interface{}, idsModified interface{}, counterType interface{}) *MockManager_ReadMessages_Call {
	return &MockManager_ReadMessages_Call{Call: _e.mock.On("ReadMessages", newOldestOrderId, idsModified, counterType)}
}

func (_c *MockManager_ReadMessages_Call) Run(run func(newOldestOrderId string, idsModified []string, counterType chatmodel.CounterType)) *MockManager_ReadMessages_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(string), args[1].([]string), args[2].(chatmodel.CounterType))
	})
	return _c
}

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

func (_c *MockManager_ReadMessages_Call) RunAndReturn(run func(string, []string, chatmodel.CounterType)) *MockManager_ReadMessages_Call {
	_c.Call.Return(run)
	return _c
}

// SetSessionContext provides a mock function with given fields: ctx
func (_m *MockManager) SetSessionContext(ctx session.Context) {
	_m.Called(ctx)
}

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

// SetSessionContext is a helper method to define mock.On call
//   - ctx session.Context
func (_e *MockManager_Expecter) SetSessionContext(ctx interface{}) *MockManager_SetSessionContext_Call {
	return &MockManager_SetSessionContext_Call{Call: _e.mock.On("SetSessionContext", ctx)}
}

func (_c *MockManager_SetSessionContext_Call) Run(run func(ctx session.Context)) *MockManager_SetSessionContext_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(session.Context))
	})
	return _c
}

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

func (_c *MockManager_SetSessionContext_Call) RunAndReturn(run func(session.Context)) *MockManager_SetSessionContext_Call {
	_c.Call.Return(run)
	return _c
}

// Unlock provides a mock function with given fields:
func (_m *MockManager) Unlock() {
	_m.Called()
}

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

// Unlock is a helper method to define mock.On call
func (_e *MockManager_Expecter) Unlock() *MockManager_Unlock_Call {
	return &MockManager_Unlock_Call{Call: _e.mock.On("Unlock")}
}

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

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

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

// UnreadMessages provides a mock function with given fields: newOldestOrderId, lastStateId, msgIds, counterType
func (_m *MockManager) UnreadMessages(newOldestOrderId string, lastStateId string, msgIds []string, counterType chatmodel.CounterType) {
	_m.Called(newOldestOrderId, lastStateId, msgIds, counterType)
}

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

// UnreadMessages is a helper method to define mock.On call
//   - newOldestOrderId string
//   - lastStateId string
//   - msgIds []string
//   - counterType chatmodel.CounterType
func (_e *MockManager_Expecter) UnreadMessages(newOldestOrderId interface{}, lastStateId interface{}, msgIds interface{}, counterType interface{}) *MockManager_UnreadMessages_Call {
	return &MockManager_UnreadMessages_Call{Call: _e.mock.On("UnreadMessages", newOldestOrderId, lastStateId, msgIds, counterType)}
}

func (_c *MockManager_UnreadMessages_Call) Run(run func(newOldestOrderId string, lastStateId string, msgIds []string, counterType chatmodel.CounterType)) *MockManager_UnreadMessages_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(string), args[1].(string), args[2].([]string), args[3].(chatmodel.CounterType))
	})
	return _c
}

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

func (_c *MockManager_UnreadMessages_Call) RunAndReturn(run func(string, string, []string, chatmodel.CounterType)) *MockManager_UnreadMessages_Call {
	_c.Call.Return(run)
	return _c
}

// UpdateChatState provides a mock function with given fields: updater
func (_m *MockManager) UpdateChatState(updater func(*model.ChatState) *model.ChatState) {
	_m.Called(updater)
}

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

// UpdateChatState is a helper method to define mock.On call
//   - updater func(*model.ChatState) *model.ChatState
func (_e *MockManager_Expecter) UpdateChatState(updater interface{}) *MockManager_UpdateChatState_Call {
	return &MockManager_UpdateChatState_Call{Call: _e.mock.On("UpdateChatState", updater)}
}

func (_c *MockManager_UpdateChatState_Call) Run(run func(updater func(*model.ChatState) *model.ChatState)) *MockManager_UpdateChatState_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(func(*model.ChatState) *model.ChatState))
	})
	return _c
}

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

func (_c *MockManager_UpdateChatState_Call) RunAndReturn(run func(func(*model.ChatState) *model.ChatState)) *MockManager_UpdateChatState_Call {
	_c.Call.Return(run)
	return _c
}

// UpdateFull provides a mock function with given fields: message
func (_m *MockManager) UpdateFull(message *chatmodel.Message) {
	_m.Called(message)
}

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

// UpdateFull is a helper method to define mock.On call
//   - message *chatmodel.Message
func (_e *MockManager_Expecter) UpdateFull(message interface{}) *MockManager_UpdateFull_Call {
	return &MockManager_UpdateFull_Call{Call: _e.mock.On("UpdateFull", message)}
}

func (_c *MockManager_UpdateFull_Call) Run(run func(message *chatmodel.Message)) *MockManager_UpdateFull_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(*chatmodel.Message))
	})
	return _c
}

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

func (_c *MockManager_UpdateFull_Call) RunAndReturn(run func(*chatmodel.Message)) *MockManager_UpdateFull_Call {
	_c.Call.Return(run)
	return _c
}

// UpdateReactions provides a mock function with given fields: message
func (_m *MockManager) UpdateReactions(message *chatmodel.Message) {
	_m.Called(message)
}

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

// UpdateReactions is a helper method to define mock.On call
//   - message *chatmodel.Message
func (_e *MockManager_Expecter) UpdateReactions(message interface{}) *MockManager_UpdateReactions_Call {
	return &MockManager_UpdateReactions_Call{Call: _e.mock.On("UpdateReactions", message)}
}

func (_c *MockManager_UpdateReactions_Call) Run(run func(message *chatmodel.Message)) *MockManager_UpdateReactions_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(*chatmodel.Message))
	})
	return _c
}

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

func (_c *MockManager_UpdateReactions_Call) RunAndReturn(run func(*chatmodel.Message)) *MockManager_UpdateReactions_Call {
	_c.Call.Return(run)
	return _c
}

// UpdateSyncStatus provides a mock function with given fields: messageIds, isSynced
func (_m *MockManager) UpdateSyncStatus(messageIds []string, isSynced bool) {
	_m.Called(messageIds, isSynced)
}

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

// UpdateSyncStatus is a helper method to define mock.On call
//   - messageIds []string
//   - isSynced bool
func (_e *MockManager_Expecter) UpdateSyncStatus(messageIds interface{}, isSynced interface{}) *MockManager_UpdateSyncStatus_Call {
	return &MockManager_UpdateSyncStatus_Call{Call: _e.mock.On("UpdateSyncStatus", messageIds, isSynced)}
}

func (_c *MockManager_UpdateSyncStatus_Call) Run(run func(messageIds []string, isSynced bool)) *MockManager_UpdateSyncStatus_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].([]string), args[1].(bool))
	})
	return _c
}

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

func (_c *MockManager_UpdateSyncStatus_Call) RunAndReturn(run func([]string, bool)) *MockManager_UpdateSyncStatus_Call {
	_c.Call.Return(run)
	return _c
}

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

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

	return mock
}
