// Code generated by mockery. DO NOT EDIT.

package mock_spacecontroller

import (
	context "context"

	mode "github.com/anyproto/anytype-heart/space/internal/spaceprocess/mode"
	mock "github.com/stretchr/testify/mock"

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

// MockSpaceController is an autogenerated mock type for the SpaceController type
type MockSpaceController struct {
	mock.Mock
}

type MockSpaceController_Expecter struct {
	mock *mock.Mock
}

func (_m *MockSpaceController) EXPECT() *MockSpaceController_Expecter {
	return &MockSpaceController_Expecter{mock: &_m.Mock}
}

// Close provides a mock function with given fields: ctx
func (_m *MockSpaceController) 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
}

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

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

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

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

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

// Current provides a mock function with given fields:
func (_m *MockSpaceController) Current() any {
	ret := _m.Called()

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

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

	return r0
}

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

// Current is a helper method to define mock.On call
func (_e *MockSpaceController_Expecter) Current() *MockSpaceController_Current_Call {
	return &MockSpaceController_Current_Call{Call: _e.mock.On("Current")}
}

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

func (_c *MockSpaceController_Current_Call) Return(_a0 any) *MockSpaceController_Current_Call {
	_c.Call.Return(_a0)
	return _c
}

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

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

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

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

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

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

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

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

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

	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
}

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

// GetStatus is a helper method to define mock.On call
func (_e *MockSpaceController_Expecter) GetStatus() *MockSpaceController_GetStatus_Call {
	return &MockSpaceController_GetStatus_Call{Call: _e.mock.On("GetStatus")}
}

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

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

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

// Mode provides a mock function with given fields:
func (_m *MockSpaceController) Mode() mode.Mode {
	ret := _m.Called()

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

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

	return r0
}

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

// Mode is a helper method to define mock.On call
func (_e *MockSpaceController_Expecter) Mode() *MockSpaceController_Mode_Call {
	return &MockSpaceController_Mode_Call{Call: _e.mock.On("Mode")}
}

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

func (_c *MockSpaceController_Mode_Call) Return(_a0 mode.Mode) *MockSpaceController_Mode_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockSpaceController_Mode_Call) RunAndReturn(run func() mode.Mode) *MockSpaceController_Mode_Call {
	_c.Call.Return(run)
	return _c
}

// SetLocalInfo provides a mock function with given fields: ctx, status
func (_m *MockSpaceController) SetLocalInfo(ctx context.Context, status spaceinfo.SpaceLocalInfo) error {
	ret := _m.Called(ctx, status)

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

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

	return r0
}

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

// SetLocalInfo is a helper method to define mock.On call
//   - ctx context.Context
//   - status spaceinfo.SpaceLocalInfo
func (_e *MockSpaceController_Expecter) SetLocalInfo(ctx interface{}, status interface{}) *MockSpaceController_SetLocalInfo_Call {
	return &MockSpaceController_SetLocalInfo_Call{Call: _e.mock.On("SetLocalInfo", ctx, status)}
}

func (_c *MockSpaceController_SetLocalInfo_Call) Run(run func(ctx context.Context, status spaceinfo.SpaceLocalInfo)) *MockSpaceController_SetLocalInfo_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(spaceinfo.SpaceLocalInfo))
	})
	return _c
}

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

func (_c *MockSpaceController_SetLocalInfo_Call) RunAndReturn(run func(context.Context, spaceinfo.SpaceLocalInfo) error) *MockSpaceController_SetLocalInfo_Call {
	_c.Call.Return(run)
	return _c
}

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

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

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

	return r0
}

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

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

func (_c *MockSpaceController_SetPersistentInfo_Call) Run(run func(ctx context.Context, info spaceinfo.SpacePersistentInfo)) *MockSpaceController_SetPersistentInfo_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(spaceinfo.SpacePersistentInfo))
	})
	return _c
}

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

func (_c *MockSpaceController_SetPersistentInfo_Call) RunAndReturn(run func(context.Context, spaceinfo.SpacePersistentInfo) error) *MockSpaceController_SetPersistentInfo_Call {
	_c.Call.Return(run)
	return _c
}

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

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

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

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

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

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

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

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

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

	return r0
}

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

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

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

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

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

// Update provides a mock function with given fields:
func (_m *MockSpaceController) Update() error {
	ret := _m.Called()

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

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

	return r0
}

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

// Update is a helper method to define mock.On call
func (_e *MockSpaceController_Expecter) Update() *MockSpaceController_Update_Call {
	return &MockSpaceController_Update_Call{Call: _e.mock.On("Update")}
}

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

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

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

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

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

	return mock
}
