// Code generated by mockery. DO NOT EDIT.

package mock_techspace

import (
	crypto "github.com/anyproto/any-sync/util/crypto"
	domain "github.com/anyproto/anytype-heart/core/domain"

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

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

	pb "github.com/anyproto/anytype-heart/pb"

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

	spaceinfo "github.com/anyproto/anytype-heart/space/spaceinfo"
)

// MockSpaceView is an autogenerated mock type for the SpaceView type
type MockSpaceView struct {
	mock.Mock
}

type MockSpaceView_Expecter struct {
	mock *mock.Mock
}

func (_m *MockSpaceView) EXPECT() *MockSpaceView_Expecter {
	return &MockSpaceView_Expecter{mock: &_m.Mock}
}

// GetLocalInfo provides a mock function with given fields:
func (_m *MockSpaceView) GetLocalInfo() spaceinfo.SpaceLocalInfo {
	ret := _m.Called()

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

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

	return r0
}

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

// GetLocalInfo is a helper method to define mock.On call
func (_e *MockSpaceView_Expecter) GetLocalInfo() *MockSpaceView_GetLocalInfo_Call {
	return &MockSpaceView_GetLocalInfo_Call{Call: _e.mock.On("GetLocalInfo")}
}

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

func (_c *MockSpaceView_GetLocalInfo_Call) Return(_a0 spaceinfo.SpaceLocalInfo) *MockSpaceView_GetLocalInfo_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockSpaceView_GetLocalInfo_Call) RunAndReturn(run func() spaceinfo.SpaceLocalInfo) *MockSpaceView_GetLocalInfo_Call {
	_c.Call.Return(run)
	return _c
}

// GetPersistentInfo provides a mock function with given fields:
func (_m *MockSpaceView) GetPersistentInfo() spaceinfo.SpacePersistentInfo {
	ret := _m.Called()

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

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

	return r0
}

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

// GetPersistentInfo is a helper method to define mock.On call
func (_e *MockSpaceView_Expecter) GetPersistentInfo() *MockSpaceView_GetPersistentInfo_Call {
	return &MockSpaceView_GetPersistentInfo_Call{Call: _e.mock.On("GetPersistentInfo")}
}

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

func (_c *MockSpaceView_GetPersistentInfo_Call) Return(_a0 spaceinfo.SpacePersistentInfo) *MockSpaceView_GetPersistentInfo_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockSpaceView_GetPersistentInfo_Call) RunAndReturn(run func() spaceinfo.SpacePersistentInfo) *MockSpaceView_GetPersistentInfo_Call {
	_c.Call.Return(run)
	return _c
}

// GetSharedSpacesLimit provides a mock function with given fields:
func (_m *MockSpaceView) GetSharedSpacesLimit() int {
	ret := _m.Called()

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

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

	return r0
}

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

// GetSharedSpacesLimit is a helper method to define mock.On call
func (_e *MockSpaceView_Expecter) GetSharedSpacesLimit() *MockSpaceView_GetSharedSpacesLimit_Call {
	return &MockSpaceView_GetSharedSpacesLimit_Call{Call: _e.mock.On("GetSharedSpacesLimit")}
}

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

func (_c *MockSpaceView_GetSharedSpacesLimit_Call) Return(limits int) *MockSpaceView_GetSharedSpacesLimit_Call {
	_c.Call.Return(limits)
	return _c
}

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

// GetSpaceDescription provides a mock function with given fields:
func (_m *MockSpaceView) GetSpaceDescription() spaceinfo.SpaceDescription {
	ret := _m.Called()

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

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

	return r0
}

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

// GetSpaceDescription is a helper method to define mock.On call
func (_e *MockSpaceView_Expecter) GetSpaceDescription() *MockSpaceView_GetSpaceDescription_Call {
	return &MockSpaceView_GetSpaceDescription_Call{Call: _e.mock.On("GetSpaceDescription")}
}

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

func (_c *MockSpaceView_GetSpaceDescription_Call) Return(data spaceinfo.SpaceDescription) *MockSpaceView_GetSpaceDescription_Call {
	_c.Call.Return(data)
	return _c
}

func (_c *MockSpaceView_GetSpaceDescription_Call) RunAndReturn(run func() spaceinfo.SpaceDescription) *MockSpaceView_GetSpaceDescription_Call {
	_c.Call.Return(run)
	return _c
}

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

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

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

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

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

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

// SetAccessType provides a mock function with given fields: acc
func (_m *MockSpaceView) SetAccessType(acc spaceinfo.AccessType) error {
	ret := _m.Called(acc)

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

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

	return r0
}

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

// SetAccessType is a helper method to define mock.On call
//   - acc spaceinfo.AccessType
func (_e *MockSpaceView_Expecter) SetAccessType(acc interface{}) *MockSpaceView_SetAccessType_Call {
	return &MockSpaceView_SetAccessType_Call{Call: _e.mock.On("SetAccessType", acc)}
}

func (_c *MockSpaceView_SetAccessType_Call) Run(run func(acc spaceinfo.AccessType)) *MockSpaceView_SetAccessType_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(spaceinfo.AccessType))
	})
	return _c
}

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

func (_c *MockSpaceView_SetAccessType_Call) RunAndReturn(run func(spaceinfo.AccessType) error) *MockSpaceView_SetAccessType_Call {
	_c.Call.Return(run)
	return _c
}

// SetAclInfo provides a mock function with given fields: empty, pushKey, pushEncKey, joinedDate
func (_m *MockSpaceView) SetAclInfo(empty bool, pushKey crypto.PrivKey, pushEncKey crypto.SymKey, joinedDate int64) error {
	ret := _m.Called(empty, pushKey, pushEncKey, joinedDate)

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

	var r0 error
	if rf, ok := ret.Get(0).(func(bool, crypto.PrivKey, crypto.SymKey, int64) error); ok {
		r0 = rf(empty, pushKey, pushEncKey, joinedDate)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

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

// SetAclInfo is a helper method to define mock.On call
//   - empty bool
//   - pushKey crypto.PrivKey
//   - pushEncKey crypto.SymKey
//   - joinedDate int64
func (_e *MockSpaceView_Expecter) SetAclInfo(empty interface{}, pushKey interface{}, pushEncKey interface{}, joinedDate interface{}) *MockSpaceView_SetAclInfo_Call {
	return &MockSpaceView_SetAclInfo_Call{Call: _e.mock.On("SetAclInfo", empty, pushKey, pushEncKey, joinedDate)}
}

func (_c *MockSpaceView_SetAclInfo_Call) Run(run func(empty bool, pushKey crypto.PrivKey, pushEncKey crypto.SymKey, joinedDate int64)) *MockSpaceView_SetAclInfo_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(bool), args[1].(crypto.PrivKey), args[2].(crypto.SymKey), args[3].(int64))
	})
	return _c
}

func (_c *MockSpaceView_SetAclInfo_Call) Return(err error) *MockSpaceView_SetAclInfo_Call {
	_c.Call.Return(err)
	return _c
}

func (_c *MockSpaceView_SetAclInfo_Call) RunAndReturn(run func(bool, crypto.PrivKey, crypto.SymKey, int64) error) *MockSpaceView_SetAclInfo_Call {
	_c.Call.Return(run)
	return _c
}

// SetMyParticipantStatus provides a mock function with given fields: status
func (_m *MockSpaceView) SetMyParticipantStatus(status model.ParticipantStatus) error {
	ret := _m.Called(status)

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

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

	return r0
}

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

// SetMyParticipantStatus is a helper method to define mock.On call
//   - status model.ParticipantStatus
func (_e *MockSpaceView_Expecter) SetMyParticipantStatus(status interface{}) *MockSpaceView_SetMyParticipantStatus_Call {
	return &MockSpaceView_SetMyParticipantStatus_Call{Call: _e.mock.On("SetMyParticipantStatus", status)}
}

func (_c *MockSpaceView_SetMyParticipantStatus_Call) Run(run func(status model.ParticipantStatus)) *MockSpaceView_SetMyParticipantStatus_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(model.ParticipantStatus))
	})
	return _c
}

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

func (_c *MockSpaceView_SetMyParticipantStatus_Call) RunAndReturn(run func(model.ParticipantStatus) error) *MockSpaceView_SetMyParticipantStatus_Call {
	_c.Call.Return(run)
	return _c
}

// SetOwner provides a mock function with given fields: ownerId, createdDate
func (_m *MockSpaceView) SetOwner(ownerId string, createdDate int64) error {
	ret := _m.Called(ownerId, createdDate)

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

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

	return r0
}

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

// SetOwner is a helper method to define mock.On call
//   - ownerId string
//   - createdDate int64
func (_e *MockSpaceView_Expecter) SetOwner(ownerId interface{}, createdDate interface{}) *MockSpaceView_SetOwner_Call {
	return &MockSpaceView_SetOwner_Call{Call: _e.mock.On("SetOwner", ownerId, createdDate)}
}

func (_c *MockSpaceView_SetOwner_Call) Run(run func(ownerId string, createdDate int64)) *MockSpaceView_SetOwner_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(string), args[1].(int64))
	})
	return _c
}

func (_c *MockSpaceView_SetOwner_Call) Return(err error) *MockSpaceView_SetOwner_Call {
	_c.Call.Return(err)
	return _c
}

func (_c *MockSpaceView_SetOwner_Call) RunAndReturn(run func(string, int64) error) *MockSpaceView_SetOwner_Call {
	_c.Call.Return(run)
	return _c
}

// SetPushNotificationMode provides a mock function with given fields: ctx, mode
func (_m *MockSpaceView) SetPushNotificationMode(ctx session.Context, mode pb.RpcPushNotificationSetSpaceModeMode) error {
	ret := _m.Called(ctx, mode)

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

	var r0 error
	if rf, ok := ret.Get(0).(func(session.Context, pb.RpcPushNotificationSetSpaceModeMode) error); ok {
		r0 = rf(ctx, mode)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

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

// SetPushNotificationMode is a helper method to define mock.On call
//   - ctx session.Context
//   - mode pb.RpcPushNotificationSetSpaceModeMode
func (_e *MockSpaceView_Expecter) SetPushNotificationMode(ctx interface{}, mode interface{}) *MockSpaceView_SetPushNotificationMode_Call {
	return &MockSpaceView_SetPushNotificationMode_Call{Call: _e.mock.On("SetPushNotificationMode", ctx, mode)}
}

func (_c *MockSpaceView_SetPushNotificationMode_Call) Run(run func(ctx session.Context, mode pb.RpcPushNotificationSetSpaceModeMode)) *MockSpaceView_SetPushNotificationMode_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(session.Context), args[1].(pb.RpcPushNotificationSetSpaceModeMode))
	})
	return _c
}

func (_c *MockSpaceView_SetPushNotificationMode_Call) Return(err error) *MockSpaceView_SetPushNotificationMode_Call {
	_c.Call.Return(err)
	return _c
}

func (_c *MockSpaceView_SetPushNotificationMode_Call) RunAndReturn(run func(session.Context, pb.RpcPushNotificationSetSpaceModeMode) error) *MockSpaceView_SetPushNotificationMode_Call {
	_c.Call.Return(run)
	return _c
}

// SetSharedSpacesLimit provides a mock function with given fields: limits
func (_m *MockSpaceView) SetSharedSpacesLimit(limits int) error {
	ret := _m.Called(limits)

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

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

	return r0
}

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

// SetSharedSpacesLimit is a helper method to define mock.On call
//   - limits int
func (_e *MockSpaceView_Expecter) SetSharedSpacesLimit(limits interface{}) *MockSpaceView_SetSharedSpacesLimit_Call {
	return &MockSpaceView_SetSharedSpacesLimit_Call{Call: _e.mock.On("SetSharedSpacesLimit", limits)}
}

func (_c *MockSpaceView_SetSharedSpacesLimit_Call) Run(run func(limits int)) *MockSpaceView_SetSharedSpacesLimit_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(int))
	})
	return _c
}

func (_c *MockSpaceView_SetSharedSpacesLimit_Call) Return(err error) *MockSpaceView_SetSharedSpacesLimit_Call {
	_c.Call.Return(err)
	return _c
}

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

// SetSpaceData provides a mock function with given fields: details
func (_m *MockSpaceView) SetSpaceData(details *domain.Details) error {
	ret := _m.Called(details)

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

	var r0 error
	if rf, ok := ret.Get(0).(func(*domain.Details) error); ok {
		r0 = rf(details)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

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

// SetSpaceData is a helper method to define mock.On call
//   - details *domain.Details
func (_e *MockSpaceView_Expecter) SetSpaceData(details interface{}) *MockSpaceView_SetSpaceData_Call {
	return &MockSpaceView_SetSpaceData_Call{Call: _e.mock.On("SetSpaceData", details)}
}

func (_c *MockSpaceView_SetSpaceData_Call) Run(run func(details *domain.Details)) *MockSpaceView_SetSpaceData_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(*domain.Details))
	})
	return _c
}

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

func (_c *MockSpaceView_SetSpaceData_Call) RunAndReturn(run func(*domain.Details) error) *MockSpaceView_SetSpaceData_Call {
	_c.Call.Return(run)
	return _c
}

// SetSpaceLocalInfo provides a mock function with given fields: info
func (_m *MockSpaceView) SetSpaceLocalInfo(info spaceinfo.SpaceLocalInfo) error {
	ret := _m.Called(info)

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

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

	return r0
}

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

// SetSpaceLocalInfo is a helper method to define mock.On call
//   - info spaceinfo.SpaceLocalInfo
func (_e *MockSpaceView_Expecter) SetSpaceLocalInfo(info interface{}) *MockSpaceView_SetSpaceLocalInfo_Call {
	return &MockSpaceView_SetSpaceLocalInfo_Call{Call: _e.mock.On("SetSpaceLocalInfo", info)}
}

func (_c *MockSpaceView_SetSpaceLocalInfo_Call) Run(run func(info spaceinfo.SpaceLocalInfo)) *MockSpaceView_SetSpaceLocalInfo_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(spaceinfo.SpaceLocalInfo))
	})
	return _c
}

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

func (_c *MockSpaceView_SetSpaceLocalInfo_Call) RunAndReturn(run func(spaceinfo.SpaceLocalInfo) error) *MockSpaceView_SetSpaceLocalInfo_Call {
	_c.Call.Return(run)
	return _c
}

// SetSpacePersistentInfo provides a mock function with given fields: info
func (_m *MockSpaceView) SetSpacePersistentInfo(info spaceinfo.SpacePersistentInfo) error {
	ret := _m.Called(info)

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

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

	return r0
}

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

// SetSpacePersistentInfo is a helper method to define mock.On call
//   - info spaceinfo.SpacePersistentInfo
func (_e *MockSpaceView_Expecter) SetSpacePersistentInfo(info interface{}) *MockSpaceView_SetSpacePersistentInfo_Call {
	return &MockSpaceView_SetSpacePersistentInfo_Call{Call: _e.mock.On("SetSpacePersistentInfo", info)}
}

func (_c *MockSpaceView_SetSpacePersistentInfo_Call) Run(run func(info spaceinfo.SpacePersistentInfo)) *MockSpaceView_SetSpacePersistentInfo_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(spaceinfo.SpacePersistentInfo))
	})
	return _c
}

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

func (_c *MockSpaceView_SetSpacePersistentInfo_Call) RunAndReturn(run func(spaceinfo.SpacePersistentInfo) error) *MockSpaceView_SetSpacePersistentInfo_Call {
	_c.Call.Return(run)
	return _c
}

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

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

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

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

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

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

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

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

	return mock
}
