// Code generated by mockery. DO NOT EDIT.

package mock_spacestatus

import (
	context "context"

	app "github.com/anyproto/any-sync/app"

	crypto "github.com/anyproto/any-sync/util/crypto"

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

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

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

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

// MockSpaceStatus is an autogenerated mock type for the SpaceStatus type
type MockSpaceStatus struct {
	mock.Mock
}

type MockSpaceStatus_Expecter struct {
	mock *mock.Mock
}

func (_m *MockSpaceStatus) EXPECT() *MockSpaceStatus_Expecter {
	return &MockSpaceStatus_Expecter{mock: &_m.Mock}
}

// Close provides a mock function with given fields: ctx
func (_m *MockSpaceStatus) Close(ctx context.Context) error {
	ret := _m.Called(ctx)

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

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

	return r0
}

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

// Close is a helper method to define mock.On call
//   - ctx context.Context
func (_e *MockSpaceStatus_Expecter) Close(ctx interface{}) *MockSpaceStatus_Close_Call {
	return &MockSpaceStatus_Close_Call{Call: _e.mock.On("Close", ctx)}
}

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

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

func (_c *MockSpaceStatus_Close_Call) RunAndReturn(run func(context.Context) error) *MockSpaceStatus_Close_Call {
	_c.Call.Return(run)
	return _c
}

// GetLatestAclHeadId provides a mock function with given fields:
func (_m *MockSpaceStatus) GetLatestAclHeadId() string {
	ret := _m.Called()

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

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

	return r0
}

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

// GetLatestAclHeadId is a helper method to define mock.On call
func (_e *MockSpaceStatus_Expecter) GetLatestAclHeadId() *MockSpaceStatus_GetLatestAclHeadId_Call {
	return &MockSpaceStatus_GetLatestAclHeadId_Call{Call: _e.mock.On("GetLatestAclHeadId")}
}

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

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

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

// GetLocalStatus provides a mock function with given fields:
func (_m *MockSpaceStatus) GetLocalStatus() spaceinfo.LocalStatus {
	ret := _m.Called()

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

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

	return r0
}

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

// GetLocalStatus is a helper method to define mock.On call
func (_e *MockSpaceStatus_Expecter) GetLocalStatus() *MockSpaceStatus_GetLocalStatus_Call {
	return &MockSpaceStatus_GetLocalStatus_Call{Call: _e.mock.On("GetLocalStatus")}
}

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

func (_c *MockSpaceStatus_GetLocalStatus_Call) Return(_a0 spaceinfo.LocalStatus) *MockSpaceStatus_GetLocalStatus_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockSpaceStatus_GetLocalStatus_Call) RunAndReturn(run func() spaceinfo.LocalStatus) *MockSpaceStatus_GetLocalStatus_Call {
	_c.Call.Return(run)
	return _c
}

// GetPersistentStatus provides a mock function with given fields:
func (_m *MockSpaceStatus) GetPersistentStatus() spaceinfo.AccountStatus {
	ret := _m.Called()

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

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

	return r0
}

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

// GetPersistentStatus is a helper method to define mock.On call
func (_e *MockSpaceStatus_Expecter) GetPersistentStatus() *MockSpaceStatus_GetPersistentStatus_Call {
	return &MockSpaceStatus_GetPersistentStatus_Call{Call: _e.mock.On("GetPersistentStatus")}
}

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

func (_c *MockSpaceStatus_GetPersistentStatus_Call) Return(_a0 spaceinfo.AccountStatus) *MockSpaceStatus_GetPersistentStatus_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockSpaceStatus_GetPersistentStatus_Call) RunAndReturn(run func() spaceinfo.AccountStatus) *MockSpaceStatus_GetPersistentStatus_Call {
	_c.Call.Return(run)
	return _c
}

// GetSpaceView provides a mock function with given fields:
func (_m *MockSpaceStatus) GetSpaceView() techspace.SpaceView {
	ret := _m.Called()

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

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

	return r0
}

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

// GetSpaceView is a helper method to define mock.On call
func (_e *MockSpaceStatus_Expecter) GetSpaceView() *MockSpaceStatus_GetSpaceView_Call {
	return &MockSpaceStatus_GetSpaceView_Call{Call: _e.mock.On("GetSpaceView")}
}

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

func (_c *MockSpaceStatus_GetSpaceView_Call) Return(_a0 techspace.SpaceView) *MockSpaceStatus_GetSpaceView_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockSpaceStatus_GetSpaceView_Call) RunAndReturn(run func() techspace.SpaceView) *MockSpaceStatus_GetSpaceView_Call {
	_c.Call.Return(run)
	return _c
}

// Init provides a mock function with given fields: a
func (_m *MockSpaceStatus) Init(a *app.App) error {
	ret := _m.Called(a)

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

	var r0 error
	if rf, ok := ret.Get(0).(func(*app.App) error); ok {
		r0 = rf(a)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

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

// Init is a helper method to define mock.On call
//   - a *app.App
func (_e *MockSpaceStatus_Expecter) Init(a interface{}) *MockSpaceStatus_Init_Call {
	return &MockSpaceStatus_Init_Call{Call: _e.mock.On("Init", a)}
}

func (_c *MockSpaceStatus_Init_Call) Run(run func(a *app.App)) *MockSpaceStatus_Init_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(*app.App))
	})
	return _c
}

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

func (_c *MockSpaceStatus_Init_Call) RunAndReturn(run func(*app.App) error) *MockSpaceStatus_Init_Call {
	_c.Call.Return(run)
	return _c
}

// Name provides a mock function with given fields:
func (_m *MockSpaceStatus) Name() string {
	ret := _m.Called()

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

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

	return r0
}

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

// Name is a helper method to define mock.On call
func (_e *MockSpaceStatus_Expecter) Name() *MockSpaceStatus_Name_Call {
	return &MockSpaceStatus_Name_Call{Call: _e.mock.On("Name")}
}

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

func (_c *MockSpaceStatus_Name_Call) Return(name string) *MockSpaceStatus_Name_Call {
	_c.Call.Return(name)
	return _c
}

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

// Run provides a mock function with given fields: ctx
func (_m *MockSpaceStatus) Run(ctx context.Context) error {
	ret := _m.Called(ctx)

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

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

	return r0
}

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

// Run is a helper method to define mock.On call
//   - ctx context.Context
func (_e *MockSpaceStatus_Expecter) Run(ctx interface{}) *MockSpaceStatus_Run_Call {
	return &MockSpaceStatus_Run_Call{Call: _e.mock.On("Run", ctx)}
}

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

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

func (_c *MockSpaceStatus_Run_Call) RunAndReturn(run func(context.Context) error) *MockSpaceStatus_Run_Call {
	_c.Call.Return(run)
	return _c
}

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

	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(status)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

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

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

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

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

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

// SetAclInfo provides a mock function with given fields: isAclEmpty, pushKey, pushEncryptionKey, joinedDate
func (_m *MockSpaceStatus) SetAclInfo(isAclEmpty bool, pushKey crypto.PrivKey, pushEncryptionKey crypto.SymKey, joinedDate int64) error {
	ret := _m.Called(isAclEmpty, pushKey, pushEncryptionKey, 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(isAclEmpty, pushKey, pushEncryptionKey, joinedDate)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

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

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

func (_c *MockSpaceStatus_SetAclInfo_Call) Run(run func(isAclEmpty bool, pushKey crypto.PrivKey, pushEncryptionKey crypto.SymKey, joinedDate int64)) *MockSpaceStatus_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 *MockSpaceStatus_SetAclInfo_Call) Return(err error) *MockSpaceStatus_SetAclInfo_Call {
	_c.Call.Return(err)
	return _c
}

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

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

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

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

	return r0
}

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

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

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

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

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

// SetLocalStatus provides a mock function with given fields: status
func (_m *MockSpaceStatus) SetLocalStatus(status spaceinfo.LocalStatus) error {
	ret := _m.Called(status)

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

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

	return r0
}

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

// SetLocalStatus is a helper method to define mock.On call
//   - status spaceinfo.LocalStatus
func (_e *MockSpaceStatus_Expecter) SetLocalStatus(status interface{}) *MockSpaceStatus_SetLocalStatus_Call {
	return &MockSpaceStatus_SetLocalStatus_Call{Call: _e.mock.On("SetLocalStatus", status)}
}

func (_c *MockSpaceStatus_SetLocalStatus_Call) Run(run func(status spaceinfo.LocalStatus)) *MockSpaceStatus_SetLocalStatus_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(spaceinfo.LocalStatus))
	})
	return _c
}

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

func (_c *MockSpaceStatus_SetLocalStatus_Call) RunAndReturn(run func(spaceinfo.LocalStatus) error) *MockSpaceStatus_SetLocalStatus_Call {
	_c.Call.Return(run)
	return _c
}

// SetMyParticipantStatus provides a mock function with given fields: status
func (_m *MockSpaceStatus) 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
}

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

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

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

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

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

// SetOwner provides a mock function with given fields: ownerIdentity, createdDate
func (_m *MockSpaceStatus) SetOwner(ownerIdentity string, createdDate int64) error {
	ret := _m.Called(ownerIdentity, 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(ownerIdentity, createdDate)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

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

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

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

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

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

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

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

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

	return r0
}

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

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

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

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

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

// SetPersistentStatus provides a mock function with given fields: status
func (_m *MockSpaceStatus) SetPersistentStatus(status spaceinfo.AccountStatus) error {
	ret := _m.Called(status)

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

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

	return r0
}

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

// SetPersistentStatus is a helper method to define mock.On call
//   - status spaceinfo.AccountStatus
func (_e *MockSpaceStatus_Expecter) SetPersistentStatus(status interface{}) *MockSpaceStatus_SetPersistentStatus_Call {
	return &MockSpaceStatus_SetPersistentStatus_Call{Call: _e.mock.On("SetPersistentStatus", status)}
}

func (_c *MockSpaceStatus_SetPersistentStatus_Call) Run(run func(status spaceinfo.AccountStatus)) *MockSpaceStatus_SetPersistentStatus_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(spaceinfo.AccountStatus))
	})
	return _c
}

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

func (_c *MockSpaceStatus_SetPersistentStatus_Call) RunAndReturn(run func(spaceinfo.AccountStatus) error) *MockSpaceStatus_SetPersistentStatus_Call {
	_c.Call.Return(run)
	return _c
}

// SpaceId provides a mock function with given fields:
func (_m *MockSpaceStatus) SpaceId() string {
	ret := _m.Called()

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

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

	return r0
}

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

// SpaceId is a helper method to define mock.On call
func (_e *MockSpaceStatus_Expecter) SpaceId() *MockSpaceStatus_SpaceId_Call {
	return &MockSpaceStatus_SpaceId_Call{Call: _e.mock.On("SpaceId")}
}

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

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

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

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

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

	return mock
}
