// Code generated by mockery. DO NOT EDIT.

package mock_apicore

import (
	context "context"

	pb "github.com/anyproto/anytype-heart/pb"
	mock "github.com/stretchr/testify/mock"
)

// MockClientCommands is an autogenerated mock type for the ClientCommands type
type MockClientCommands struct {
	mock.Mock
}

type MockClientCommands_Expecter struct {
	mock *mock.Mock
}

func (_m *MockClientCommands) EXPECT() *MockClientCommands_Expecter {
	return &MockClientCommands_Expecter{mock: &_m.Mock}
}

// AccountLocalLinkNewChallenge provides a mock function with given fields: _a0, _a1
func (_m *MockClientCommands) AccountLocalLinkNewChallenge(_a0 context.Context, _a1 *pb.RpcAccountLocalLinkNewChallengeRequest) *pb.RpcAccountLocalLinkNewChallengeResponse {
	ret := _m.Called(_a0, _a1)

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

	var r0 *pb.RpcAccountLocalLinkNewChallengeResponse
	if rf, ok := ret.Get(0).(func(context.Context, *pb.RpcAccountLocalLinkNewChallengeRequest) *pb.RpcAccountLocalLinkNewChallengeResponse); ok {
		r0 = rf(_a0, _a1)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*pb.RpcAccountLocalLinkNewChallengeResponse)
		}
	}

	return r0
}

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

// AccountLocalLinkNewChallenge is a helper method to define mock.On call
//   - _a0 context.Context
//   - _a1 *pb.RpcAccountLocalLinkNewChallengeRequest
func (_e *MockClientCommands_Expecter) AccountLocalLinkNewChallenge(_a0 interface{}, _a1 interface{}) *MockClientCommands_AccountLocalLinkNewChallenge_Call {
	return &MockClientCommands_AccountLocalLinkNewChallenge_Call{Call: _e.mock.On("AccountLocalLinkNewChallenge", _a0, _a1)}
}

func (_c *MockClientCommands_AccountLocalLinkNewChallenge_Call) Run(run func(_a0 context.Context, _a1 *pb.RpcAccountLocalLinkNewChallengeRequest)) *MockClientCommands_AccountLocalLinkNewChallenge_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(*pb.RpcAccountLocalLinkNewChallengeRequest))
	})
	return _c
}

func (_c *MockClientCommands_AccountLocalLinkNewChallenge_Call) Return(_a0 *pb.RpcAccountLocalLinkNewChallengeResponse) *MockClientCommands_AccountLocalLinkNewChallenge_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockClientCommands_AccountLocalLinkNewChallenge_Call) RunAndReturn(run func(context.Context, *pb.RpcAccountLocalLinkNewChallengeRequest) *pb.RpcAccountLocalLinkNewChallengeResponse) *MockClientCommands_AccountLocalLinkNewChallenge_Call {
	_c.Call.Return(run)
	return _c
}

// AccountLocalLinkSolveChallenge provides a mock function with given fields: _a0, _a1
func (_m *MockClientCommands) AccountLocalLinkSolveChallenge(_a0 context.Context, _a1 *pb.RpcAccountLocalLinkSolveChallengeRequest) *pb.RpcAccountLocalLinkSolveChallengeResponse {
	ret := _m.Called(_a0, _a1)

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

	var r0 *pb.RpcAccountLocalLinkSolveChallengeResponse
	if rf, ok := ret.Get(0).(func(context.Context, *pb.RpcAccountLocalLinkSolveChallengeRequest) *pb.RpcAccountLocalLinkSolveChallengeResponse); ok {
		r0 = rf(_a0, _a1)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*pb.RpcAccountLocalLinkSolveChallengeResponse)
		}
	}

	return r0
}

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

// AccountLocalLinkSolveChallenge is a helper method to define mock.On call
//   - _a0 context.Context
//   - _a1 *pb.RpcAccountLocalLinkSolveChallengeRequest
func (_e *MockClientCommands_Expecter) AccountLocalLinkSolveChallenge(_a0 interface{}, _a1 interface{}) *MockClientCommands_AccountLocalLinkSolveChallenge_Call {
	return &MockClientCommands_AccountLocalLinkSolveChallenge_Call{Call: _e.mock.On("AccountLocalLinkSolveChallenge", _a0, _a1)}
}

func (_c *MockClientCommands_AccountLocalLinkSolveChallenge_Call) Run(run func(_a0 context.Context, _a1 *pb.RpcAccountLocalLinkSolveChallengeRequest)) *MockClientCommands_AccountLocalLinkSolveChallenge_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(*pb.RpcAccountLocalLinkSolveChallengeRequest))
	})
	return _c
}

func (_c *MockClientCommands_AccountLocalLinkSolveChallenge_Call) Return(_a0 *pb.RpcAccountLocalLinkSolveChallengeResponse) *MockClientCommands_AccountLocalLinkSolveChallenge_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockClientCommands_AccountLocalLinkSolveChallenge_Call) RunAndReturn(run func(context.Context, *pb.RpcAccountLocalLinkSolveChallengeRequest) *pb.RpcAccountLocalLinkSolveChallengeResponse) *MockClientCommands_AccountLocalLinkSolveChallenge_Call {
	_c.Call.Return(run)
	return _c
}

// BlockCreate provides a mock function with given fields: _a0, _a1
func (_m *MockClientCommands) BlockCreate(_a0 context.Context, _a1 *pb.RpcBlockCreateRequest) *pb.RpcBlockCreateResponse {
	ret := _m.Called(_a0, _a1)

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

	var r0 *pb.RpcBlockCreateResponse
	if rf, ok := ret.Get(0).(func(context.Context, *pb.RpcBlockCreateRequest) *pb.RpcBlockCreateResponse); ok {
		r0 = rf(_a0, _a1)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*pb.RpcBlockCreateResponse)
		}
	}

	return r0
}

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

// BlockCreate is a helper method to define mock.On call
//   - _a0 context.Context
//   - _a1 *pb.RpcBlockCreateRequest
func (_e *MockClientCommands_Expecter) BlockCreate(_a0 interface{}, _a1 interface{}) *MockClientCommands_BlockCreate_Call {
	return &MockClientCommands_BlockCreate_Call{Call: _e.mock.On("BlockCreate", _a0, _a1)}
}

func (_c *MockClientCommands_BlockCreate_Call) Run(run func(_a0 context.Context, _a1 *pb.RpcBlockCreateRequest)) *MockClientCommands_BlockCreate_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(*pb.RpcBlockCreateRequest))
	})
	return _c
}

func (_c *MockClientCommands_BlockCreate_Call) Return(_a0 *pb.RpcBlockCreateResponse) *MockClientCommands_BlockCreate_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockClientCommands_BlockCreate_Call) RunAndReturn(run func(context.Context, *pb.RpcBlockCreateRequest) *pb.RpcBlockCreateResponse) *MockClientCommands_BlockCreate_Call {
	_c.Call.Return(run)
	return _c
}

// BlockPaste provides a mock function with given fields: _a0, _a1
func (_m *MockClientCommands) BlockPaste(_a0 context.Context, _a1 *pb.RpcBlockPasteRequest) *pb.RpcBlockPasteResponse {
	ret := _m.Called(_a0, _a1)

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

	var r0 *pb.RpcBlockPasteResponse
	if rf, ok := ret.Get(0).(func(context.Context, *pb.RpcBlockPasteRequest) *pb.RpcBlockPasteResponse); ok {
		r0 = rf(_a0, _a1)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*pb.RpcBlockPasteResponse)
		}
	}

	return r0
}

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

// BlockPaste is a helper method to define mock.On call
//   - _a0 context.Context
//   - _a1 *pb.RpcBlockPasteRequest
func (_e *MockClientCommands_Expecter) BlockPaste(_a0 interface{}, _a1 interface{}) *MockClientCommands_BlockPaste_Call {
	return &MockClientCommands_BlockPaste_Call{Call: _e.mock.On("BlockPaste", _a0, _a1)}
}

func (_c *MockClientCommands_BlockPaste_Call) Run(run func(_a0 context.Context, _a1 *pb.RpcBlockPasteRequest)) *MockClientCommands_BlockPaste_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(*pb.RpcBlockPasteRequest))
	})
	return _c
}

func (_c *MockClientCommands_BlockPaste_Call) Return(_a0 *pb.RpcBlockPasteResponse) *MockClientCommands_BlockPaste_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockClientCommands_BlockPaste_Call) RunAndReturn(run func(context.Context, *pb.RpcBlockPasteRequest) *pb.RpcBlockPasteResponse) *MockClientCommands_BlockPaste_Call {
	_c.Call.Return(run)
	return _c
}

// ObjectCollectionAdd provides a mock function with given fields: _a0, _a1
func (_m *MockClientCommands) ObjectCollectionAdd(_a0 context.Context, _a1 *pb.RpcObjectCollectionAddRequest) *pb.RpcObjectCollectionAddResponse {
	ret := _m.Called(_a0, _a1)

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

	var r0 *pb.RpcObjectCollectionAddResponse
	if rf, ok := ret.Get(0).(func(context.Context, *pb.RpcObjectCollectionAddRequest) *pb.RpcObjectCollectionAddResponse); ok {
		r0 = rf(_a0, _a1)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*pb.RpcObjectCollectionAddResponse)
		}
	}

	return r0
}

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

// ObjectCollectionAdd is a helper method to define mock.On call
//   - _a0 context.Context
//   - _a1 *pb.RpcObjectCollectionAddRequest
func (_e *MockClientCommands_Expecter) ObjectCollectionAdd(_a0 interface{}, _a1 interface{}) *MockClientCommands_ObjectCollectionAdd_Call {
	return &MockClientCommands_ObjectCollectionAdd_Call{Call: _e.mock.On("ObjectCollectionAdd", _a0, _a1)}
}

func (_c *MockClientCommands_ObjectCollectionAdd_Call) Run(run func(_a0 context.Context, _a1 *pb.RpcObjectCollectionAddRequest)) *MockClientCommands_ObjectCollectionAdd_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(*pb.RpcObjectCollectionAddRequest))
	})
	return _c
}

func (_c *MockClientCommands_ObjectCollectionAdd_Call) Return(_a0 *pb.RpcObjectCollectionAddResponse) *MockClientCommands_ObjectCollectionAdd_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockClientCommands_ObjectCollectionAdd_Call) RunAndReturn(run func(context.Context, *pb.RpcObjectCollectionAddRequest) *pb.RpcObjectCollectionAddResponse) *MockClientCommands_ObjectCollectionAdd_Call {
	_c.Call.Return(run)
	return _c
}

// ObjectCollectionRemove provides a mock function with given fields: _a0, _a1
func (_m *MockClientCommands) ObjectCollectionRemove(_a0 context.Context, _a1 *pb.RpcObjectCollectionRemoveRequest) *pb.RpcObjectCollectionRemoveResponse {
	ret := _m.Called(_a0, _a1)

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

	var r0 *pb.RpcObjectCollectionRemoveResponse
	if rf, ok := ret.Get(0).(func(context.Context, *pb.RpcObjectCollectionRemoveRequest) *pb.RpcObjectCollectionRemoveResponse); ok {
		r0 = rf(_a0, _a1)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*pb.RpcObjectCollectionRemoveResponse)
		}
	}

	return r0
}

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

// ObjectCollectionRemove is a helper method to define mock.On call
//   - _a0 context.Context
//   - _a1 *pb.RpcObjectCollectionRemoveRequest
func (_e *MockClientCommands_Expecter) ObjectCollectionRemove(_a0 interface{}, _a1 interface{}) *MockClientCommands_ObjectCollectionRemove_Call {
	return &MockClientCommands_ObjectCollectionRemove_Call{Call: _e.mock.On("ObjectCollectionRemove", _a0, _a1)}
}

func (_c *MockClientCommands_ObjectCollectionRemove_Call) Run(run func(_a0 context.Context, _a1 *pb.RpcObjectCollectionRemoveRequest)) *MockClientCommands_ObjectCollectionRemove_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(*pb.RpcObjectCollectionRemoveRequest))
	})
	return _c
}

func (_c *MockClientCommands_ObjectCollectionRemove_Call) Return(_a0 *pb.RpcObjectCollectionRemoveResponse) *MockClientCommands_ObjectCollectionRemove_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockClientCommands_ObjectCollectionRemove_Call) RunAndReturn(run func(context.Context, *pb.RpcObjectCollectionRemoveRequest) *pb.RpcObjectCollectionRemoveResponse) *MockClientCommands_ObjectCollectionRemove_Call {
	_c.Call.Return(run)
	return _c
}

// ObjectCreate provides a mock function with given fields: _a0, _a1
func (_m *MockClientCommands) ObjectCreate(_a0 context.Context, _a1 *pb.RpcObjectCreateRequest) *pb.RpcObjectCreateResponse {
	ret := _m.Called(_a0, _a1)

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

	var r0 *pb.RpcObjectCreateResponse
	if rf, ok := ret.Get(0).(func(context.Context, *pb.RpcObjectCreateRequest) *pb.RpcObjectCreateResponse); ok {
		r0 = rf(_a0, _a1)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*pb.RpcObjectCreateResponse)
		}
	}

	return r0
}

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

// ObjectCreate is a helper method to define mock.On call
//   - _a0 context.Context
//   - _a1 *pb.RpcObjectCreateRequest
func (_e *MockClientCommands_Expecter) ObjectCreate(_a0 interface{}, _a1 interface{}) *MockClientCommands_ObjectCreate_Call {
	return &MockClientCommands_ObjectCreate_Call{Call: _e.mock.On("ObjectCreate", _a0, _a1)}
}

func (_c *MockClientCommands_ObjectCreate_Call) Run(run func(_a0 context.Context, _a1 *pb.RpcObjectCreateRequest)) *MockClientCommands_ObjectCreate_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(*pb.RpcObjectCreateRequest))
	})
	return _c
}

func (_c *MockClientCommands_ObjectCreate_Call) Return(_a0 *pb.RpcObjectCreateResponse) *MockClientCommands_ObjectCreate_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockClientCommands_ObjectCreate_Call) RunAndReturn(run func(context.Context, *pb.RpcObjectCreateRequest) *pb.RpcObjectCreateResponse) *MockClientCommands_ObjectCreate_Call {
	_c.Call.Return(run)
	return _c
}

// ObjectCreateBookmark provides a mock function with given fields: _a0, _a1
func (_m *MockClientCommands) ObjectCreateBookmark(_a0 context.Context, _a1 *pb.RpcObjectCreateBookmarkRequest) *pb.RpcObjectCreateBookmarkResponse {
	ret := _m.Called(_a0, _a1)

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

	var r0 *pb.RpcObjectCreateBookmarkResponse
	if rf, ok := ret.Get(0).(func(context.Context, *pb.RpcObjectCreateBookmarkRequest) *pb.RpcObjectCreateBookmarkResponse); ok {
		r0 = rf(_a0, _a1)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*pb.RpcObjectCreateBookmarkResponse)
		}
	}

	return r0
}

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

// ObjectCreateBookmark is a helper method to define mock.On call
//   - _a0 context.Context
//   - _a1 *pb.RpcObjectCreateBookmarkRequest
func (_e *MockClientCommands_Expecter) ObjectCreateBookmark(_a0 interface{}, _a1 interface{}) *MockClientCommands_ObjectCreateBookmark_Call {
	return &MockClientCommands_ObjectCreateBookmark_Call{Call: _e.mock.On("ObjectCreateBookmark", _a0, _a1)}
}

func (_c *MockClientCommands_ObjectCreateBookmark_Call) Run(run func(_a0 context.Context, _a1 *pb.RpcObjectCreateBookmarkRequest)) *MockClientCommands_ObjectCreateBookmark_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(*pb.RpcObjectCreateBookmarkRequest))
	})
	return _c
}

func (_c *MockClientCommands_ObjectCreateBookmark_Call) Return(_a0 *pb.RpcObjectCreateBookmarkResponse) *MockClientCommands_ObjectCreateBookmark_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockClientCommands_ObjectCreateBookmark_Call) RunAndReturn(run func(context.Context, *pb.RpcObjectCreateBookmarkRequest) *pb.RpcObjectCreateBookmarkResponse) *MockClientCommands_ObjectCreateBookmark_Call {
	_c.Call.Return(run)
	return _c
}

// ObjectCreateObjectType provides a mock function with given fields: _a0, _a1
func (_m *MockClientCommands) ObjectCreateObjectType(_a0 context.Context, _a1 *pb.RpcObjectCreateObjectTypeRequest) *pb.RpcObjectCreateObjectTypeResponse {
	ret := _m.Called(_a0, _a1)

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

	var r0 *pb.RpcObjectCreateObjectTypeResponse
	if rf, ok := ret.Get(0).(func(context.Context, *pb.RpcObjectCreateObjectTypeRequest) *pb.RpcObjectCreateObjectTypeResponse); ok {
		r0 = rf(_a0, _a1)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*pb.RpcObjectCreateObjectTypeResponse)
		}
	}

	return r0
}

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

// ObjectCreateObjectType is a helper method to define mock.On call
//   - _a0 context.Context
//   - _a1 *pb.RpcObjectCreateObjectTypeRequest
func (_e *MockClientCommands_Expecter) ObjectCreateObjectType(_a0 interface{}, _a1 interface{}) *MockClientCommands_ObjectCreateObjectType_Call {
	return &MockClientCommands_ObjectCreateObjectType_Call{Call: _e.mock.On("ObjectCreateObjectType", _a0, _a1)}
}

func (_c *MockClientCommands_ObjectCreateObjectType_Call) Run(run func(_a0 context.Context, _a1 *pb.RpcObjectCreateObjectTypeRequest)) *MockClientCommands_ObjectCreateObjectType_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(*pb.RpcObjectCreateObjectTypeRequest))
	})
	return _c
}

func (_c *MockClientCommands_ObjectCreateObjectType_Call) Return(_a0 *pb.RpcObjectCreateObjectTypeResponse) *MockClientCommands_ObjectCreateObjectType_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockClientCommands_ObjectCreateObjectType_Call) RunAndReturn(run func(context.Context, *pb.RpcObjectCreateObjectTypeRequest) *pb.RpcObjectCreateObjectTypeResponse) *MockClientCommands_ObjectCreateObjectType_Call {
	_c.Call.Return(run)
	return _c
}

// ObjectCreateRelation provides a mock function with given fields: _a0, _a1
func (_m *MockClientCommands) ObjectCreateRelation(_a0 context.Context, _a1 *pb.RpcObjectCreateRelationRequest) *pb.RpcObjectCreateRelationResponse {
	ret := _m.Called(_a0, _a1)

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

	var r0 *pb.RpcObjectCreateRelationResponse
	if rf, ok := ret.Get(0).(func(context.Context, *pb.RpcObjectCreateRelationRequest) *pb.RpcObjectCreateRelationResponse); ok {
		r0 = rf(_a0, _a1)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*pb.RpcObjectCreateRelationResponse)
		}
	}

	return r0
}

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

// ObjectCreateRelation is a helper method to define mock.On call
//   - _a0 context.Context
//   - _a1 *pb.RpcObjectCreateRelationRequest
func (_e *MockClientCommands_Expecter) ObjectCreateRelation(_a0 interface{}, _a1 interface{}) *MockClientCommands_ObjectCreateRelation_Call {
	return &MockClientCommands_ObjectCreateRelation_Call{Call: _e.mock.On("ObjectCreateRelation", _a0, _a1)}
}

func (_c *MockClientCommands_ObjectCreateRelation_Call) Run(run func(_a0 context.Context, _a1 *pb.RpcObjectCreateRelationRequest)) *MockClientCommands_ObjectCreateRelation_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(*pb.RpcObjectCreateRelationRequest))
	})
	return _c
}

func (_c *MockClientCommands_ObjectCreateRelation_Call) Return(_a0 *pb.RpcObjectCreateRelationResponse) *MockClientCommands_ObjectCreateRelation_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockClientCommands_ObjectCreateRelation_Call) RunAndReturn(run func(context.Context, *pb.RpcObjectCreateRelationRequest) *pb.RpcObjectCreateRelationResponse) *MockClientCommands_ObjectCreateRelation_Call {
	_c.Call.Return(run)
	return _c
}

// ObjectCreateRelationOption provides a mock function with given fields: _a0, _a1
func (_m *MockClientCommands) ObjectCreateRelationOption(_a0 context.Context, _a1 *pb.RpcObjectCreateRelationOptionRequest) *pb.RpcObjectCreateRelationOptionResponse {
	ret := _m.Called(_a0, _a1)

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

	var r0 *pb.RpcObjectCreateRelationOptionResponse
	if rf, ok := ret.Get(0).(func(context.Context, *pb.RpcObjectCreateRelationOptionRequest) *pb.RpcObjectCreateRelationOptionResponse); ok {
		r0 = rf(_a0, _a1)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*pb.RpcObjectCreateRelationOptionResponse)
		}
	}

	return r0
}

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

// ObjectCreateRelationOption is a helper method to define mock.On call
//   - _a0 context.Context
//   - _a1 *pb.RpcObjectCreateRelationOptionRequest
func (_e *MockClientCommands_Expecter) ObjectCreateRelationOption(_a0 interface{}, _a1 interface{}) *MockClientCommands_ObjectCreateRelationOption_Call {
	return &MockClientCommands_ObjectCreateRelationOption_Call{Call: _e.mock.On("ObjectCreateRelationOption", _a0, _a1)}
}

func (_c *MockClientCommands_ObjectCreateRelationOption_Call) Run(run func(_a0 context.Context, _a1 *pb.RpcObjectCreateRelationOptionRequest)) *MockClientCommands_ObjectCreateRelationOption_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(*pb.RpcObjectCreateRelationOptionRequest))
	})
	return _c
}

func (_c *MockClientCommands_ObjectCreateRelationOption_Call) Return(_a0 *pb.RpcObjectCreateRelationOptionResponse) *MockClientCommands_ObjectCreateRelationOption_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockClientCommands_ObjectCreateRelationOption_Call) RunAndReturn(run func(context.Context, *pb.RpcObjectCreateRelationOptionRequest) *pb.RpcObjectCreateRelationOptionResponse) *MockClientCommands_ObjectCreateRelationOption_Call {
	_c.Call.Return(run)
	return _c
}

// ObjectExport provides a mock function with given fields: _a0, _a1
func (_m *MockClientCommands) ObjectExport(_a0 context.Context, _a1 *pb.RpcObjectExportRequest) *pb.RpcObjectExportResponse {
	ret := _m.Called(_a0, _a1)

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

	var r0 *pb.RpcObjectExportResponse
	if rf, ok := ret.Get(0).(func(context.Context, *pb.RpcObjectExportRequest) *pb.RpcObjectExportResponse); ok {
		r0 = rf(_a0, _a1)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*pb.RpcObjectExportResponse)
		}
	}

	return r0
}

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

// ObjectExport is a helper method to define mock.On call
//   - _a0 context.Context
//   - _a1 *pb.RpcObjectExportRequest
func (_e *MockClientCommands_Expecter) ObjectExport(_a0 interface{}, _a1 interface{}) *MockClientCommands_ObjectExport_Call {
	return &MockClientCommands_ObjectExport_Call{Call: _e.mock.On("ObjectExport", _a0, _a1)}
}

func (_c *MockClientCommands_ObjectExport_Call) Run(run func(_a0 context.Context, _a1 *pb.RpcObjectExportRequest)) *MockClientCommands_ObjectExport_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(*pb.RpcObjectExportRequest))
	})
	return _c
}

func (_c *MockClientCommands_ObjectExport_Call) Return(_a0 *pb.RpcObjectExportResponse) *MockClientCommands_ObjectExport_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockClientCommands_ObjectExport_Call) RunAndReturn(run func(context.Context, *pb.RpcObjectExportRequest) *pb.RpcObjectExportResponse) *MockClientCommands_ObjectExport_Call {
	_c.Call.Return(run)
	return _c
}

// ObjectRelationAddFeatured provides a mock function with given fields: _a0, _a1
func (_m *MockClientCommands) ObjectRelationAddFeatured(_a0 context.Context, _a1 *pb.RpcObjectRelationAddFeaturedRequest) *pb.RpcObjectRelationAddFeaturedResponse {
	ret := _m.Called(_a0, _a1)

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

	var r0 *pb.RpcObjectRelationAddFeaturedResponse
	if rf, ok := ret.Get(0).(func(context.Context, *pb.RpcObjectRelationAddFeaturedRequest) *pb.RpcObjectRelationAddFeaturedResponse); ok {
		r0 = rf(_a0, _a1)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*pb.RpcObjectRelationAddFeaturedResponse)
		}
	}

	return r0
}

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

// ObjectRelationAddFeatured is a helper method to define mock.On call
//   - _a0 context.Context
//   - _a1 *pb.RpcObjectRelationAddFeaturedRequest
func (_e *MockClientCommands_Expecter) ObjectRelationAddFeatured(_a0 interface{}, _a1 interface{}) *MockClientCommands_ObjectRelationAddFeatured_Call {
	return &MockClientCommands_ObjectRelationAddFeatured_Call{Call: _e.mock.On("ObjectRelationAddFeatured", _a0, _a1)}
}

func (_c *MockClientCommands_ObjectRelationAddFeatured_Call) Run(run func(_a0 context.Context, _a1 *pb.RpcObjectRelationAddFeaturedRequest)) *MockClientCommands_ObjectRelationAddFeatured_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(*pb.RpcObjectRelationAddFeaturedRequest))
	})
	return _c
}

func (_c *MockClientCommands_ObjectRelationAddFeatured_Call) Return(_a0 *pb.RpcObjectRelationAddFeaturedResponse) *MockClientCommands_ObjectRelationAddFeatured_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockClientCommands_ObjectRelationAddFeatured_Call) RunAndReturn(run func(context.Context, *pb.RpcObjectRelationAddFeaturedRequest) *pb.RpcObjectRelationAddFeaturedResponse) *MockClientCommands_ObjectRelationAddFeatured_Call {
	_c.Call.Return(run)
	return _c
}

// ObjectSearch provides a mock function with given fields: _a0, _a1
func (_m *MockClientCommands) ObjectSearch(_a0 context.Context, _a1 *pb.RpcObjectSearchRequest) *pb.RpcObjectSearchResponse {
	ret := _m.Called(_a0, _a1)

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

	var r0 *pb.RpcObjectSearchResponse
	if rf, ok := ret.Get(0).(func(context.Context, *pb.RpcObjectSearchRequest) *pb.RpcObjectSearchResponse); ok {
		r0 = rf(_a0, _a1)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*pb.RpcObjectSearchResponse)
		}
	}

	return r0
}

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

// ObjectSearch is a helper method to define mock.On call
//   - _a0 context.Context
//   - _a1 *pb.RpcObjectSearchRequest
func (_e *MockClientCommands_Expecter) ObjectSearch(_a0 interface{}, _a1 interface{}) *MockClientCommands_ObjectSearch_Call {
	return &MockClientCommands_ObjectSearch_Call{Call: _e.mock.On("ObjectSearch", _a0, _a1)}
}

func (_c *MockClientCommands_ObjectSearch_Call) Run(run func(_a0 context.Context, _a1 *pb.RpcObjectSearchRequest)) *MockClientCommands_ObjectSearch_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(*pb.RpcObjectSearchRequest))
	})
	return _c
}

func (_c *MockClientCommands_ObjectSearch_Call) Return(_a0 *pb.RpcObjectSearchResponse) *MockClientCommands_ObjectSearch_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockClientCommands_ObjectSearch_Call) RunAndReturn(run func(context.Context, *pb.RpcObjectSearchRequest) *pb.RpcObjectSearchResponse) *MockClientCommands_ObjectSearch_Call {
	_c.Call.Return(run)
	return _c
}

// ObjectSearchSubscribe provides a mock function with given fields: _a0, _a1
func (_m *MockClientCommands) ObjectSearchSubscribe(_a0 context.Context, _a1 *pb.RpcObjectSearchSubscribeRequest) *pb.RpcObjectSearchSubscribeResponse {
	ret := _m.Called(_a0, _a1)

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

	var r0 *pb.RpcObjectSearchSubscribeResponse
	if rf, ok := ret.Get(0).(func(context.Context, *pb.RpcObjectSearchSubscribeRequest) *pb.RpcObjectSearchSubscribeResponse); ok {
		r0 = rf(_a0, _a1)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*pb.RpcObjectSearchSubscribeResponse)
		}
	}

	return r0
}

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

// ObjectSearchSubscribe is a helper method to define mock.On call
//   - _a0 context.Context
//   - _a1 *pb.RpcObjectSearchSubscribeRequest
func (_e *MockClientCommands_Expecter) ObjectSearchSubscribe(_a0 interface{}, _a1 interface{}) *MockClientCommands_ObjectSearchSubscribe_Call {
	return &MockClientCommands_ObjectSearchSubscribe_Call{Call: _e.mock.On("ObjectSearchSubscribe", _a0, _a1)}
}

func (_c *MockClientCommands_ObjectSearchSubscribe_Call) Run(run func(_a0 context.Context, _a1 *pb.RpcObjectSearchSubscribeRequest)) *MockClientCommands_ObjectSearchSubscribe_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(*pb.RpcObjectSearchSubscribeRequest))
	})
	return _c
}

func (_c *MockClientCommands_ObjectSearchSubscribe_Call) Return(_a0 *pb.RpcObjectSearchSubscribeResponse) *MockClientCommands_ObjectSearchSubscribe_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockClientCommands_ObjectSearchSubscribe_Call) RunAndReturn(run func(context.Context, *pb.RpcObjectSearchSubscribeRequest) *pb.RpcObjectSearchSubscribeResponse) *MockClientCommands_ObjectSearchSubscribe_Call {
	_c.Call.Return(run)
	return _c
}

// ObjectSearchUnsubscribe provides a mock function with given fields: _a0, _a1
func (_m *MockClientCommands) ObjectSearchUnsubscribe(_a0 context.Context, _a1 *pb.RpcObjectSearchUnsubscribeRequest) *pb.RpcObjectSearchUnsubscribeResponse {
	ret := _m.Called(_a0, _a1)

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

	var r0 *pb.RpcObjectSearchUnsubscribeResponse
	if rf, ok := ret.Get(0).(func(context.Context, *pb.RpcObjectSearchUnsubscribeRequest) *pb.RpcObjectSearchUnsubscribeResponse); ok {
		r0 = rf(_a0, _a1)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*pb.RpcObjectSearchUnsubscribeResponse)
		}
	}

	return r0
}

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

// ObjectSearchUnsubscribe is a helper method to define mock.On call
//   - _a0 context.Context
//   - _a1 *pb.RpcObjectSearchUnsubscribeRequest
func (_e *MockClientCommands_Expecter) ObjectSearchUnsubscribe(_a0 interface{}, _a1 interface{}) *MockClientCommands_ObjectSearchUnsubscribe_Call {
	return &MockClientCommands_ObjectSearchUnsubscribe_Call{Call: _e.mock.On("ObjectSearchUnsubscribe", _a0, _a1)}
}

func (_c *MockClientCommands_ObjectSearchUnsubscribe_Call) Run(run func(_a0 context.Context, _a1 *pb.RpcObjectSearchUnsubscribeRequest)) *MockClientCommands_ObjectSearchUnsubscribe_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(*pb.RpcObjectSearchUnsubscribeRequest))
	})
	return _c
}

func (_c *MockClientCommands_ObjectSearchUnsubscribe_Call) Return(_a0 *pb.RpcObjectSearchUnsubscribeResponse) *MockClientCommands_ObjectSearchUnsubscribe_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockClientCommands_ObjectSearchUnsubscribe_Call) RunAndReturn(run func(context.Context, *pb.RpcObjectSearchUnsubscribeRequest) *pb.RpcObjectSearchUnsubscribeResponse) *MockClientCommands_ObjectSearchUnsubscribe_Call {
	_c.Call.Return(run)
	return _c
}

// ObjectSetDetails provides a mock function with given fields: _a0, _a1
func (_m *MockClientCommands) ObjectSetDetails(_a0 context.Context, _a1 *pb.RpcObjectSetDetailsRequest) *pb.RpcObjectSetDetailsResponse {
	ret := _m.Called(_a0, _a1)

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

	var r0 *pb.RpcObjectSetDetailsResponse
	if rf, ok := ret.Get(0).(func(context.Context, *pb.RpcObjectSetDetailsRequest) *pb.RpcObjectSetDetailsResponse); ok {
		r0 = rf(_a0, _a1)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*pb.RpcObjectSetDetailsResponse)
		}
	}

	return r0
}

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

// ObjectSetDetails is a helper method to define mock.On call
//   - _a0 context.Context
//   - _a1 *pb.RpcObjectSetDetailsRequest
func (_e *MockClientCommands_Expecter) ObjectSetDetails(_a0 interface{}, _a1 interface{}) *MockClientCommands_ObjectSetDetails_Call {
	return &MockClientCommands_ObjectSetDetails_Call{Call: _e.mock.On("ObjectSetDetails", _a0, _a1)}
}

func (_c *MockClientCommands_ObjectSetDetails_Call) Run(run func(_a0 context.Context, _a1 *pb.RpcObjectSetDetailsRequest)) *MockClientCommands_ObjectSetDetails_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(*pb.RpcObjectSetDetailsRequest))
	})
	return _c
}

func (_c *MockClientCommands_ObjectSetDetails_Call) Return(_a0 *pb.RpcObjectSetDetailsResponse) *MockClientCommands_ObjectSetDetails_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockClientCommands_ObjectSetDetails_Call) RunAndReturn(run func(context.Context, *pb.RpcObjectSetDetailsRequest) *pb.RpcObjectSetDetailsResponse) *MockClientCommands_ObjectSetDetails_Call {
	_c.Call.Return(run)
	return _c
}

// ObjectSetIsArchived provides a mock function with given fields: _a0, _a1
func (_m *MockClientCommands) ObjectSetIsArchived(_a0 context.Context, _a1 *pb.RpcObjectSetIsArchivedRequest) *pb.RpcObjectSetIsArchivedResponse {
	ret := _m.Called(_a0, _a1)

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

	var r0 *pb.RpcObjectSetIsArchivedResponse
	if rf, ok := ret.Get(0).(func(context.Context, *pb.RpcObjectSetIsArchivedRequest) *pb.RpcObjectSetIsArchivedResponse); ok {
		r0 = rf(_a0, _a1)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*pb.RpcObjectSetIsArchivedResponse)
		}
	}

	return r0
}

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

// ObjectSetIsArchived is a helper method to define mock.On call
//   - _a0 context.Context
//   - _a1 *pb.RpcObjectSetIsArchivedRequest
func (_e *MockClientCommands_Expecter) ObjectSetIsArchived(_a0 interface{}, _a1 interface{}) *MockClientCommands_ObjectSetIsArchived_Call {
	return &MockClientCommands_ObjectSetIsArchived_Call{Call: _e.mock.On("ObjectSetIsArchived", _a0, _a1)}
}

func (_c *MockClientCommands_ObjectSetIsArchived_Call) Run(run func(_a0 context.Context, _a1 *pb.RpcObjectSetIsArchivedRequest)) *MockClientCommands_ObjectSetIsArchived_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(*pb.RpcObjectSetIsArchivedRequest))
	})
	return _c
}

func (_c *MockClientCommands_ObjectSetIsArchived_Call) Return(_a0 *pb.RpcObjectSetIsArchivedResponse) *MockClientCommands_ObjectSetIsArchived_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockClientCommands_ObjectSetIsArchived_Call) RunAndReturn(run func(context.Context, *pb.RpcObjectSetIsArchivedRequest) *pb.RpcObjectSetIsArchivedResponse) *MockClientCommands_ObjectSetIsArchived_Call {
	_c.Call.Return(run)
	return _c
}

// ObjectShow provides a mock function with given fields: _a0, _a1
func (_m *MockClientCommands) ObjectShow(_a0 context.Context, _a1 *pb.RpcObjectShowRequest) *pb.RpcObjectShowResponse {
	ret := _m.Called(_a0, _a1)

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

	var r0 *pb.RpcObjectShowResponse
	if rf, ok := ret.Get(0).(func(context.Context, *pb.RpcObjectShowRequest) *pb.RpcObjectShowResponse); ok {
		r0 = rf(_a0, _a1)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*pb.RpcObjectShowResponse)
		}
	}

	return r0
}

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

// ObjectShow is a helper method to define mock.On call
//   - _a0 context.Context
//   - _a1 *pb.RpcObjectShowRequest
func (_e *MockClientCommands_Expecter) ObjectShow(_a0 interface{}, _a1 interface{}) *MockClientCommands_ObjectShow_Call {
	return &MockClientCommands_ObjectShow_Call{Call: _e.mock.On("ObjectShow", _a0, _a1)}
}

func (_c *MockClientCommands_ObjectShow_Call) Run(run func(_a0 context.Context, _a1 *pb.RpcObjectShowRequest)) *MockClientCommands_ObjectShow_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(*pb.RpcObjectShowRequest))
	})
	return _c
}

func (_c *MockClientCommands_ObjectShow_Call) Return(_a0 *pb.RpcObjectShowResponse) *MockClientCommands_ObjectShow_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockClientCommands_ObjectShow_Call) RunAndReturn(run func(context.Context, *pb.RpcObjectShowRequest) *pb.RpcObjectShowResponse) *MockClientCommands_ObjectShow_Call {
	_c.Call.Return(run)
	return _c
}

// RelationListRemoveOption provides a mock function with given fields: _a0, _a1
func (_m *MockClientCommands) RelationListRemoveOption(_a0 context.Context, _a1 *pb.RpcRelationListRemoveOptionRequest) *pb.RpcRelationListRemoveOptionResponse {
	ret := _m.Called(_a0, _a1)

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

	var r0 *pb.RpcRelationListRemoveOptionResponse
	if rf, ok := ret.Get(0).(func(context.Context, *pb.RpcRelationListRemoveOptionRequest) *pb.RpcRelationListRemoveOptionResponse); ok {
		r0 = rf(_a0, _a1)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*pb.RpcRelationListRemoveOptionResponse)
		}
	}

	return r0
}

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

// RelationListRemoveOption is a helper method to define mock.On call
//   - _a0 context.Context
//   - _a1 *pb.RpcRelationListRemoveOptionRequest
func (_e *MockClientCommands_Expecter) RelationListRemoveOption(_a0 interface{}, _a1 interface{}) *MockClientCommands_RelationListRemoveOption_Call {
	return &MockClientCommands_RelationListRemoveOption_Call{Call: _e.mock.On("RelationListRemoveOption", _a0, _a1)}
}

func (_c *MockClientCommands_RelationListRemoveOption_Call) Run(run func(_a0 context.Context, _a1 *pb.RpcRelationListRemoveOptionRequest)) *MockClientCommands_RelationListRemoveOption_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(*pb.RpcRelationListRemoveOptionRequest))
	})
	return _c
}

func (_c *MockClientCommands_RelationListRemoveOption_Call) Return(_a0 *pb.RpcRelationListRemoveOptionResponse) *MockClientCommands_RelationListRemoveOption_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockClientCommands_RelationListRemoveOption_Call) RunAndReturn(run func(context.Context, *pb.RpcRelationListRemoveOptionRequest) *pb.RpcRelationListRemoveOptionResponse) *MockClientCommands_RelationListRemoveOption_Call {
	_c.Call.Return(run)
	return _c
}

// RelationOptions provides a mock function with given fields: _a0, _a1
func (_m *MockClientCommands) RelationOptions(_a0 context.Context, _a1 *pb.RpcRelationOptionsRequest) *pb.RpcRelationOptionsResponse {
	ret := _m.Called(_a0, _a1)

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

	var r0 *pb.RpcRelationOptionsResponse
	if rf, ok := ret.Get(0).(func(context.Context, *pb.RpcRelationOptionsRequest) *pb.RpcRelationOptionsResponse); ok {
		r0 = rf(_a0, _a1)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*pb.RpcRelationOptionsResponse)
		}
	}

	return r0
}

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

// RelationOptions is a helper method to define mock.On call
//   - _a0 context.Context
//   - _a1 *pb.RpcRelationOptionsRequest
func (_e *MockClientCommands_Expecter) RelationOptions(_a0 interface{}, _a1 interface{}) *MockClientCommands_RelationOptions_Call {
	return &MockClientCommands_RelationOptions_Call{Call: _e.mock.On("RelationOptions", _a0, _a1)}
}

func (_c *MockClientCommands_RelationOptions_Call) Run(run func(_a0 context.Context, _a1 *pb.RpcRelationOptionsRequest)) *MockClientCommands_RelationOptions_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(*pb.RpcRelationOptionsRequest))
	})
	return _c
}

func (_c *MockClientCommands_RelationOptions_Call) Return(_a0 *pb.RpcRelationOptionsResponse) *MockClientCommands_RelationOptions_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockClientCommands_RelationOptions_Call) RunAndReturn(run func(context.Context, *pb.RpcRelationOptionsRequest) *pb.RpcRelationOptionsResponse) *MockClientCommands_RelationOptions_Call {
	_c.Call.Return(run)
	return _c
}

// SpaceParticipantPermissionsChange provides a mock function with given fields: _a0, _a1
func (_m *MockClientCommands) SpaceParticipantPermissionsChange(_a0 context.Context, _a1 *pb.RpcSpaceParticipantPermissionsChangeRequest) *pb.RpcSpaceParticipantPermissionsChangeResponse {
	ret := _m.Called(_a0, _a1)

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

	var r0 *pb.RpcSpaceParticipantPermissionsChangeResponse
	if rf, ok := ret.Get(0).(func(context.Context, *pb.RpcSpaceParticipantPermissionsChangeRequest) *pb.RpcSpaceParticipantPermissionsChangeResponse); ok {
		r0 = rf(_a0, _a1)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*pb.RpcSpaceParticipantPermissionsChangeResponse)
		}
	}

	return r0
}

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

// SpaceParticipantPermissionsChange is a helper method to define mock.On call
//   - _a0 context.Context
//   - _a1 *pb.RpcSpaceParticipantPermissionsChangeRequest
func (_e *MockClientCommands_Expecter) SpaceParticipantPermissionsChange(_a0 interface{}, _a1 interface{}) *MockClientCommands_SpaceParticipantPermissionsChange_Call {
	return &MockClientCommands_SpaceParticipantPermissionsChange_Call{Call: _e.mock.On("SpaceParticipantPermissionsChange", _a0, _a1)}
}

func (_c *MockClientCommands_SpaceParticipantPermissionsChange_Call) Run(run func(_a0 context.Context, _a1 *pb.RpcSpaceParticipantPermissionsChangeRequest)) *MockClientCommands_SpaceParticipantPermissionsChange_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(*pb.RpcSpaceParticipantPermissionsChangeRequest))
	})
	return _c
}

func (_c *MockClientCommands_SpaceParticipantPermissionsChange_Call) Return(_a0 *pb.RpcSpaceParticipantPermissionsChangeResponse) *MockClientCommands_SpaceParticipantPermissionsChange_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockClientCommands_SpaceParticipantPermissionsChange_Call) RunAndReturn(run func(context.Context, *pb.RpcSpaceParticipantPermissionsChangeRequest) *pb.RpcSpaceParticipantPermissionsChangeResponse) *MockClientCommands_SpaceParticipantPermissionsChange_Call {
	_c.Call.Return(run)
	return _c
}

// SpaceParticipantRemove provides a mock function with given fields: _a0, _a1
func (_m *MockClientCommands) SpaceParticipantRemove(_a0 context.Context, _a1 *pb.RpcSpaceParticipantRemoveRequest) *pb.RpcSpaceParticipantRemoveResponse {
	ret := _m.Called(_a0, _a1)

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

	var r0 *pb.RpcSpaceParticipantRemoveResponse
	if rf, ok := ret.Get(0).(func(context.Context, *pb.RpcSpaceParticipantRemoveRequest) *pb.RpcSpaceParticipantRemoveResponse); ok {
		r0 = rf(_a0, _a1)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*pb.RpcSpaceParticipantRemoveResponse)
		}
	}

	return r0
}

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

// SpaceParticipantRemove is a helper method to define mock.On call
//   - _a0 context.Context
//   - _a1 *pb.RpcSpaceParticipantRemoveRequest
func (_e *MockClientCommands_Expecter) SpaceParticipantRemove(_a0 interface{}, _a1 interface{}) *MockClientCommands_SpaceParticipantRemove_Call {
	return &MockClientCommands_SpaceParticipantRemove_Call{Call: _e.mock.On("SpaceParticipantRemove", _a0, _a1)}
}

func (_c *MockClientCommands_SpaceParticipantRemove_Call) Run(run func(_a0 context.Context, _a1 *pb.RpcSpaceParticipantRemoveRequest)) *MockClientCommands_SpaceParticipantRemove_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(*pb.RpcSpaceParticipantRemoveRequest))
	})
	return _c
}

func (_c *MockClientCommands_SpaceParticipantRemove_Call) Return(_a0 *pb.RpcSpaceParticipantRemoveResponse) *MockClientCommands_SpaceParticipantRemove_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockClientCommands_SpaceParticipantRemove_Call) RunAndReturn(run func(context.Context, *pb.RpcSpaceParticipantRemoveRequest) *pb.RpcSpaceParticipantRemoveResponse) *MockClientCommands_SpaceParticipantRemove_Call {
	_c.Call.Return(run)
	return _c
}

// SpaceRequestApprove provides a mock function with given fields: _a0, _a1
func (_m *MockClientCommands) SpaceRequestApprove(_a0 context.Context, _a1 *pb.RpcSpaceRequestApproveRequest) *pb.RpcSpaceRequestApproveResponse {
	ret := _m.Called(_a0, _a1)

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

	var r0 *pb.RpcSpaceRequestApproveResponse
	if rf, ok := ret.Get(0).(func(context.Context, *pb.RpcSpaceRequestApproveRequest) *pb.RpcSpaceRequestApproveResponse); ok {
		r0 = rf(_a0, _a1)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*pb.RpcSpaceRequestApproveResponse)
		}
	}

	return r0
}

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

// SpaceRequestApprove is a helper method to define mock.On call
//   - _a0 context.Context
//   - _a1 *pb.RpcSpaceRequestApproveRequest
func (_e *MockClientCommands_Expecter) SpaceRequestApprove(_a0 interface{}, _a1 interface{}) *MockClientCommands_SpaceRequestApprove_Call {
	return &MockClientCommands_SpaceRequestApprove_Call{Call: _e.mock.On("SpaceRequestApprove", _a0, _a1)}
}

func (_c *MockClientCommands_SpaceRequestApprove_Call) Run(run func(_a0 context.Context, _a1 *pb.RpcSpaceRequestApproveRequest)) *MockClientCommands_SpaceRequestApprove_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(*pb.RpcSpaceRequestApproveRequest))
	})
	return _c
}

func (_c *MockClientCommands_SpaceRequestApprove_Call) Return(_a0 *pb.RpcSpaceRequestApproveResponse) *MockClientCommands_SpaceRequestApprove_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockClientCommands_SpaceRequestApprove_Call) RunAndReturn(run func(context.Context, *pb.RpcSpaceRequestApproveRequest) *pb.RpcSpaceRequestApproveResponse) *MockClientCommands_SpaceRequestApprove_Call {
	_c.Call.Return(run)
	return _c
}

// SpaceRequestDecline provides a mock function with given fields: _a0, _a1
func (_m *MockClientCommands) SpaceRequestDecline(_a0 context.Context, _a1 *pb.RpcSpaceRequestDeclineRequest) *pb.RpcSpaceRequestDeclineResponse {
	ret := _m.Called(_a0, _a1)

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

	var r0 *pb.RpcSpaceRequestDeclineResponse
	if rf, ok := ret.Get(0).(func(context.Context, *pb.RpcSpaceRequestDeclineRequest) *pb.RpcSpaceRequestDeclineResponse); ok {
		r0 = rf(_a0, _a1)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*pb.RpcSpaceRequestDeclineResponse)
		}
	}

	return r0
}

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

// SpaceRequestDecline is a helper method to define mock.On call
//   - _a0 context.Context
//   - _a1 *pb.RpcSpaceRequestDeclineRequest
func (_e *MockClientCommands_Expecter) SpaceRequestDecline(_a0 interface{}, _a1 interface{}) *MockClientCommands_SpaceRequestDecline_Call {
	return &MockClientCommands_SpaceRequestDecline_Call{Call: _e.mock.On("SpaceRequestDecline", _a0, _a1)}
}

func (_c *MockClientCommands_SpaceRequestDecline_Call) Run(run func(_a0 context.Context, _a1 *pb.RpcSpaceRequestDeclineRequest)) *MockClientCommands_SpaceRequestDecline_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(*pb.RpcSpaceRequestDeclineRequest))
	})
	return _c
}

func (_c *MockClientCommands_SpaceRequestDecline_Call) Return(_a0 *pb.RpcSpaceRequestDeclineResponse) *MockClientCommands_SpaceRequestDecline_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockClientCommands_SpaceRequestDecline_Call) RunAndReturn(run func(context.Context, *pb.RpcSpaceRequestDeclineRequest) *pb.RpcSpaceRequestDeclineResponse) *MockClientCommands_SpaceRequestDecline_Call {
	_c.Call.Return(run)
	return _c
}

// WalletCreateSession provides a mock function with given fields: _a0, _a1
func (_m *MockClientCommands) WalletCreateSession(_a0 context.Context, _a1 *pb.RpcWalletCreateSessionRequest) *pb.RpcWalletCreateSessionResponse {
	ret := _m.Called(_a0, _a1)

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

	var r0 *pb.RpcWalletCreateSessionResponse
	if rf, ok := ret.Get(0).(func(context.Context, *pb.RpcWalletCreateSessionRequest) *pb.RpcWalletCreateSessionResponse); ok {
		r0 = rf(_a0, _a1)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*pb.RpcWalletCreateSessionResponse)
		}
	}

	return r0
}

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

// WalletCreateSession is a helper method to define mock.On call
//   - _a0 context.Context
//   - _a1 *pb.RpcWalletCreateSessionRequest
func (_e *MockClientCommands_Expecter) WalletCreateSession(_a0 interface{}, _a1 interface{}) *MockClientCommands_WalletCreateSession_Call {
	return &MockClientCommands_WalletCreateSession_Call{Call: _e.mock.On("WalletCreateSession", _a0, _a1)}
}

func (_c *MockClientCommands_WalletCreateSession_Call) Run(run func(_a0 context.Context, _a1 *pb.RpcWalletCreateSessionRequest)) *MockClientCommands_WalletCreateSession_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(*pb.RpcWalletCreateSessionRequest))
	})
	return _c
}

func (_c *MockClientCommands_WalletCreateSession_Call) Return(_a0 *pb.RpcWalletCreateSessionResponse) *MockClientCommands_WalletCreateSession_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockClientCommands_WalletCreateSession_Call) RunAndReturn(run func(context.Context, *pb.RpcWalletCreateSessionRequest) *pb.RpcWalletCreateSessionResponse) *MockClientCommands_WalletCreateSession_Call {
	_c.Call.Return(run)
	return _c
}

// WorkspaceCreate provides a mock function with given fields: _a0, _a1
func (_m *MockClientCommands) WorkspaceCreate(_a0 context.Context, _a1 *pb.RpcWorkspaceCreateRequest) *pb.RpcWorkspaceCreateResponse {
	ret := _m.Called(_a0, _a1)

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

	var r0 *pb.RpcWorkspaceCreateResponse
	if rf, ok := ret.Get(0).(func(context.Context, *pb.RpcWorkspaceCreateRequest) *pb.RpcWorkspaceCreateResponse); ok {
		r0 = rf(_a0, _a1)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*pb.RpcWorkspaceCreateResponse)
		}
	}

	return r0
}

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

// WorkspaceCreate is a helper method to define mock.On call
//   - _a0 context.Context
//   - _a1 *pb.RpcWorkspaceCreateRequest
func (_e *MockClientCommands_Expecter) WorkspaceCreate(_a0 interface{}, _a1 interface{}) *MockClientCommands_WorkspaceCreate_Call {
	return &MockClientCommands_WorkspaceCreate_Call{Call: _e.mock.On("WorkspaceCreate", _a0, _a1)}
}

func (_c *MockClientCommands_WorkspaceCreate_Call) Run(run func(_a0 context.Context, _a1 *pb.RpcWorkspaceCreateRequest)) *MockClientCommands_WorkspaceCreate_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(*pb.RpcWorkspaceCreateRequest))
	})
	return _c
}

func (_c *MockClientCommands_WorkspaceCreate_Call) Return(_a0 *pb.RpcWorkspaceCreateResponse) *MockClientCommands_WorkspaceCreate_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockClientCommands_WorkspaceCreate_Call) RunAndReturn(run func(context.Context, *pb.RpcWorkspaceCreateRequest) *pb.RpcWorkspaceCreateResponse) *MockClientCommands_WorkspaceCreate_Call {
	_c.Call.Return(run)
	return _c
}

// WorkspaceOpen provides a mock function with given fields: _a0, _a1
func (_m *MockClientCommands) WorkspaceOpen(_a0 context.Context, _a1 *pb.RpcWorkspaceOpenRequest) *pb.RpcWorkspaceOpenResponse {
	ret := _m.Called(_a0, _a1)

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

	var r0 *pb.RpcWorkspaceOpenResponse
	if rf, ok := ret.Get(0).(func(context.Context, *pb.RpcWorkspaceOpenRequest) *pb.RpcWorkspaceOpenResponse); ok {
		r0 = rf(_a0, _a1)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*pb.RpcWorkspaceOpenResponse)
		}
	}

	return r0
}

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

// WorkspaceOpen is a helper method to define mock.On call
//   - _a0 context.Context
//   - _a1 *pb.RpcWorkspaceOpenRequest
func (_e *MockClientCommands_Expecter) WorkspaceOpen(_a0 interface{}, _a1 interface{}) *MockClientCommands_WorkspaceOpen_Call {
	return &MockClientCommands_WorkspaceOpen_Call{Call: _e.mock.On("WorkspaceOpen", _a0, _a1)}
}

func (_c *MockClientCommands_WorkspaceOpen_Call) Run(run func(_a0 context.Context, _a1 *pb.RpcWorkspaceOpenRequest)) *MockClientCommands_WorkspaceOpen_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(*pb.RpcWorkspaceOpenRequest))
	})
	return _c
}

func (_c *MockClientCommands_WorkspaceOpen_Call) Return(_a0 *pb.RpcWorkspaceOpenResponse) *MockClientCommands_WorkspaceOpen_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockClientCommands_WorkspaceOpen_Call) RunAndReturn(run func(context.Context, *pb.RpcWorkspaceOpenRequest) *pb.RpcWorkspaceOpenResponse) *MockClientCommands_WorkspaceOpen_Call {
	_c.Call.Return(run)
	return _c
}

// WorkspaceSetInfo provides a mock function with given fields: _a0, _a1
func (_m *MockClientCommands) WorkspaceSetInfo(_a0 context.Context, _a1 *pb.RpcWorkspaceSetInfoRequest) *pb.RpcWorkspaceSetInfoResponse {
	ret := _m.Called(_a0, _a1)

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

	var r0 *pb.RpcWorkspaceSetInfoResponse
	if rf, ok := ret.Get(0).(func(context.Context, *pb.RpcWorkspaceSetInfoRequest) *pb.RpcWorkspaceSetInfoResponse); ok {
		r0 = rf(_a0, _a1)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*pb.RpcWorkspaceSetInfoResponse)
		}
	}

	return r0
}

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

// WorkspaceSetInfo is a helper method to define mock.On call
//   - _a0 context.Context
//   - _a1 *pb.RpcWorkspaceSetInfoRequest
func (_e *MockClientCommands_Expecter) WorkspaceSetInfo(_a0 interface{}, _a1 interface{}) *MockClientCommands_WorkspaceSetInfo_Call {
	return &MockClientCommands_WorkspaceSetInfo_Call{Call: _e.mock.On("WorkspaceSetInfo", _a0, _a1)}
}

func (_c *MockClientCommands_WorkspaceSetInfo_Call) Run(run func(_a0 context.Context, _a1 *pb.RpcWorkspaceSetInfoRequest)) *MockClientCommands_WorkspaceSetInfo_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(*pb.RpcWorkspaceSetInfoRequest))
	})
	return _c
}

func (_c *MockClientCommands_WorkspaceSetInfo_Call) Return(_a0 *pb.RpcWorkspaceSetInfoResponse) *MockClientCommands_WorkspaceSetInfo_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockClientCommands_WorkspaceSetInfo_Call) RunAndReturn(run func(context.Context, *pb.RpcWorkspaceSetInfoRequest) *pb.RpcWorkspaceSetInfoResponse) *MockClientCommands_WorkspaceSetInfo_Call {
	_c.Call.Return(run)
	return _c
}

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

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

	return mock
}
