// Code generated by mockery. DO NOT EDIT.

package mock_chatobject

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

	chatobject "github.com/anyproto/anytype-heart/core/block/editor/chatobject"

	chatrepository "github.com/anyproto/anytype-heart/core/block/chats/chatrepository"

	context "context"

	coresmartblock "github.com/anyproto/anytype-heart/pkg/lib/core/smartblock"

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

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

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

	objecttree "github.com/anyproto/any-sync/commonspace/object/tree/objecttree"

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

	pbtypes "github.com/anyproto/anytype-heart/util/pbtypes"

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

	restriction "github.com/anyproto/anytype-heart/core/block/restriction"

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

	simple "github.com/anyproto/anytype-heart/core/block/simple"

	smartblock "github.com/anyproto/anytype-heart/core/block/editor/smartblock"

	state "github.com/anyproto/anytype-heart/core/block/editor/state"

	time "time"

	undo "github.com/anyproto/anytype-heart/core/block/undo"
)

// MockStoreObject is an autogenerated mock type for the StoreObject type
type MockStoreObject struct {
	mock.Mock
}

type MockStoreObject_Expecter struct {
	mock *mock.Mock
}

func (_m *MockStoreObject) EXPECT() *MockStoreObject_Expecter {
	return &MockStoreObject_Expecter{mock: &_m.Mock}
}

// AddHook provides a mock function with given fields: f, events
func (_m *MockStoreObject) AddHook(f smartblock.HookCallback, events ...smartblock.Hook) {
	_va := make([]interface{}, len(events))
	for _i := range events {
		_va[_i] = events[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, f)
	_ca = append(_ca, _va...)
	_m.Called(_ca...)
}

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

// AddHook is a helper method to define mock.On call
//   - f smartblock.HookCallback
//   - events ...smartblock.Hook
func (_e *MockStoreObject_Expecter) AddHook(f interface{}, events ...interface{}) *MockStoreObject_AddHook_Call {
	return &MockStoreObject_AddHook_Call{Call: _e.mock.On("AddHook",
		append([]interface{}{f}, events...)...)}
}

func (_c *MockStoreObject_AddHook_Call) Run(run func(f smartblock.HookCallback, events ...smartblock.Hook)) *MockStoreObject_AddHook_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]smartblock.Hook, len(args)-1)
		for i, a := range args[1:] {
			if a != nil {
				variadicArgs[i] = a.(smartblock.Hook)
			}
		}
		run(args[0].(smartblock.HookCallback), variadicArgs...)
	})
	return _c
}

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

func (_c *MockStoreObject_AddHook_Call) RunAndReturn(run func(smartblock.HookCallback, ...smartblock.Hook)) *MockStoreObject_AddHook_Call {
	_c.Call.Return(run)
	return _c
}

// AddHookOnce provides a mock function with given fields: id, f, events
func (_m *MockStoreObject) AddHookOnce(id string, f smartblock.HookCallback, events ...smartblock.Hook) {
	_va := make([]interface{}, len(events))
	for _i := range events {
		_va[_i] = events[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, id, f)
	_ca = append(_ca, _va...)
	_m.Called(_ca...)
}

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

// AddHookOnce is a helper method to define mock.On call
//   - id string
//   - f smartblock.HookCallback
//   - events ...smartblock.Hook
func (_e *MockStoreObject_Expecter) AddHookOnce(id interface{}, f interface{}, events ...interface{}) *MockStoreObject_AddHookOnce_Call {
	return &MockStoreObject_AddHookOnce_Call{Call: _e.mock.On("AddHookOnce",
		append([]interface{}{id, f}, events...)...)}
}

func (_c *MockStoreObject_AddHookOnce_Call) Run(run func(id string, f smartblock.HookCallback, events ...smartblock.Hook)) *MockStoreObject_AddHookOnce_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]smartblock.Hook, len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(smartblock.Hook)
			}
		}
		run(args[0].(string), args[1].(smartblock.HookCallback), variadicArgs...)
	})
	return _c
}

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

func (_c *MockStoreObject_AddHookOnce_Call) RunAndReturn(run func(string, smartblock.HookCallback, ...smartblock.Hook)) *MockStoreObject_AddHookOnce_Call {
	_c.Call.Return(run)
	return _c
}

// AddMessage provides a mock function with given fields: ctx, sessionCtx, message
func (_m *MockStoreObject) AddMessage(ctx context.Context, sessionCtx session.Context, message *chatmodel.Message) (string, error) {
	ret := _m.Called(ctx, sessionCtx, message)

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

	var r0 string
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, session.Context, *chatmodel.Message) (string, error)); ok {
		return rf(ctx, sessionCtx, message)
	}
	if rf, ok := ret.Get(0).(func(context.Context, session.Context, *chatmodel.Message) string); ok {
		r0 = rf(ctx, sessionCtx, message)
	} else {
		r0 = ret.Get(0).(string)
	}

	if rf, ok := ret.Get(1).(func(context.Context, session.Context, *chatmodel.Message) error); ok {
		r1 = rf(ctx, sessionCtx, message)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// AddMessage is a helper method to define mock.On call
//   - ctx context.Context
//   - sessionCtx session.Context
//   - message *chatmodel.Message
func (_e *MockStoreObject_Expecter) AddMessage(ctx interface{}, sessionCtx interface{}, message interface{}) *MockStoreObject_AddMessage_Call {
	return &MockStoreObject_AddMessage_Call{Call: _e.mock.On("AddMessage", ctx, sessionCtx, message)}
}

func (_c *MockStoreObject_AddMessage_Call) Run(run func(ctx context.Context, sessionCtx session.Context, message *chatmodel.Message)) *MockStoreObject_AddMessage_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(session.Context), args[2].(*chatmodel.Message))
	})
	return _c
}

func (_c *MockStoreObject_AddMessage_Call) Return(_a0 string, _a1 error) *MockStoreObject_AddMessage_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockStoreObject_AddMessage_Call) RunAndReturn(run func(context.Context, session.Context, *chatmodel.Message) (string, error)) *MockStoreObject_AddMessage_Call {
	_c.Call.Return(run)
	return _c
}

// AddRelationLinksToState provides a mock function with given fields: s, relationKeys
func (_m *MockStoreObject) AddRelationLinksToState(s *state.State, relationKeys ...domain.RelationKey) error {
	_va := make([]interface{}, len(relationKeys))
	for _i := range relationKeys {
		_va[_i] = relationKeys[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, s)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

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

	var r0 error
	if rf, ok := ret.Get(0).(func(*state.State, ...domain.RelationKey) error); ok {
		r0 = rf(s, relationKeys...)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

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

// AddRelationLinksToState is a helper method to define mock.On call
//   - s *state.State
//   - relationKeys ...domain.RelationKey
func (_e *MockStoreObject_Expecter) AddRelationLinksToState(s interface{}, relationKeys ...interface{}) *MockStoreObject_AddRelationLinksToState_Call {
	return &MockStoreObject_AddRelationLinksToState_Call{Call: _e.mock.On("AddRelationLinksToState",
		append([]interface{}{s}, relationKeys...)...)}
}

func (_c *MockStoreObject_AddRelationLinksToState_Call) Run(run func(s *state.State, relationKeys ...domain.RelationKey)) *MockStoreObject_AddRelationLinksToState_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]domain.RelationKey, len(args)-1)
		for i, a := range args[1:] {
			if a != nil {
				variadicArgs[i] = a.(domain.RelationKey)
			}
		}
		run(args[0].(*state.State), variadicArgs...)
	})
	return _c
}

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

func (_c *MockStoreObject_AddRelationLinksToState_Call) RunAndReturn(run func(*state.State, ...domain.RelationKey) error) *MockStoreObject_AddRelationLinksToState_Call {
	_c.Call.Return(run)
	return _c
}

// Apply provides a mock function with given fields: s, flags
func (_m *MockStoreObject) Apply(s *state.State, flags ...smartblock.ApplyFlag) error {
	_va := make([]interface{}, len(flags))
	for _i := range flags {
		_va[_i] = flags[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, s)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

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

	var r0 error
	if rf, ok := ret.Get(0).(func(*state.State, ...smartblock.ApplyFlag) error); ok {
		r0 = rf(s, flags...)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

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

// Apply is a helper method to define mock.On call
//   - s *state.State
//   - flags ...smartblock.ApplyFlag
func (_e *MockStoreObject_Expecter) Apply(s interface{}, flags ...interface{}) *MockStoreObject_Apply_Call {
	return &MockStoreObject_Apply_Call{Call: _e.mock.On("Apply",
		append([]interface{}{s}, flags...)...)}
}

func (_c *MockStoreObject_Apply_Call) Run(run func(s *state.State, flags ...smartblock.ApplyFlag)) *MockStoreObject_Apply_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]smartblock.ApplyFlag, len(args)-1)
		for i, a := range args[1:] {
			if a != nil {
				variadicArgs[i] = a.(smartblock.ApplyFlag)
			}
		}
		run(args[0].(*state.State), variadicArgs...)
	})
	return _c
}

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

func (_c *MockStoreObject_Apply_Call) RunAndReturn(run func(*state.State, ...smartblock.ApplyFlag) error) *MockStoreObject_Apply_Call {
	_c.Call.Return(run)
	return _c
}

// Blocks provides a mock function with given fields:
func (_m *MockStoreObject) Blocks() []*model.Block {
	ret := _m.Called()

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

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

	return r0
}

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

// Blocks is a helper method to define mock.On call
func (_e *MockStoreObject_Expecter) Blocks() *MockStoreObject_Blocks_Call {
	return &MockStoreObject_Blocks_Call{Call: _e.mock.On("Blocks")}
}

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

func (_c *MockStoreObject_Blocks_Call) Return(_a0 []*model.Block) *MockStoreObject_Blocks_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockStoreObject_Blocks_Call) RunAndReturn(run func() []*model.Block) *MockStoreObject_Blocks_Call {
	_c.Call.Return(run)
	return _c
}

// BlocksInit provides a mock function with given fields: ds
func (_m *MockStoreObject) BlocksInit(ds simple.DetailsService) {
	_m.Called(ds)
}

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

// BlocksInit is a helper method to define mock.On call
//   - ds simple.DetailsService
func (_e *MockStoreObject_Expecter) BlocksInit(ds interface{}) *MockStoreObject_BlocksInit_Call {
	return &MockStoreObject_BlocksInit_Call{Call: _e.mock.On("BlocksInit", ds)}
}

func (_c *MockStoreObject_BlocksInit_Call) Run(run func(ds simple.DetailsService)) *MockStoreObject_BlocksInit_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(simple.DetailsService))
	})
	return _c
}

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

func (_c *MockStoreObject_BlocksInit_Call) RunAndReturn(run func(simple.DetailsService)) *MockStoreObject_BlocksInit_Call {
	_c.Call.Return(run)
	return _c
}

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

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

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

	return r0
}

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

// ChangeId is a helper method to define mock.On call
func (_e *MockStoreObject_Expecter) ChangeId() *MockStoreObject_ChangeId_Call {
	return &MockStoreObject_ChangeId_Call{Call: _e.mock.On("ChangeId")}
}

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

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

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

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

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

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

	return r0
}

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

// CheckSubscriptions is a helper method to define mock.On call
func (_e *MockStoreObject_Expecter) CheckSubscriptions() *MockStoreObject_CheckSubscriptions_Call {
	return &MockStoreObject_CheckSubscriptions_Call{Call: _e.mock.On("CheckSubscriptions")}
}

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

func (_c *MockStoreObject_CheckSubscriptions_Call) Return(changed bool) *MockStoreObject_CheckSubscriptions_Call {
	_c.Call.Return(changed)
	return _c
}

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

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

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

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

	return r0
}

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

// Close is a helper method to define mock.On call
func (_e *MockStoreObject_Expecter) Close() *MockStoreObject_Close_Call {
	return &MockStoreObject_Close_Call{Call: _e.mock.On("Close")}
}

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

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

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

// CombinedDetails provides a mock function with given fields:
func (_m *MockStoreObject) CombinedDetails() *domain.Details {
	ret := _m.Called()

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

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

	return r0
}

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

// CombinedDetails is a helper method to define mock.On call
func (_e *MockStoreObject_Expecter) CombinedDetails() *MockStoreObject_CombinedDetails_Call {
	return &MockStoreObject_CombinedDetails_Call{Call: _e.mock.On("CombinedDetails")}
}

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

func (_c *MockStoreObject_CombinedDetails_Call) Return(_a0 *domain.Details) *MockStoreObject_CombinedDetails_Call {
	_c.Call.Return(_a0)
	return _c
}

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

// DebugChanges provides a mock function with given fields: ctx
func (_m *MockStoreObject) DebugChanges(ctx context.Context) ([]*anystoredebug.DebugChange, error) {
	ret := _m.Called(ctx)

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

	var r0 []*anystoredebug.DebugChange
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context) ([]*anystoredebug.DebugChange, error)); ok {
		return rf(ctx)
	}
	if rf, ok := ret.Get(0).(func(context.Context) []*anystoredebug.DebugChange); ok {
		r0 = rf(ctx)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]*anystoredebug.DebugChange)
		}
	}

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

	return r0, r1
}

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

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

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

func (_c *MockStoreObject_DebugChanges_Call) Return(_a0 []*anystoredebug.DebugChange, _a1 error) *MockStoreObject_DebugChanges_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockStoreObject_DebugChanges_Call) RunAndReturn(run func(context.Context) ([]*anystoredebug.DebugChange, error)) *MockStoreObject_DebugChanges_Call {
	_c.Call.Return(run)
	return _c
}

// DeleteMessage provides a mock function with given fields: ctx, messageId
func (_m *MockStoreObject) DeleteMessage(ctx context.Context, messageId string) error {
	ret := _m.Called(ctx, messageId)

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

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

	return r0
}

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

// DeleteMessage is a helper method to define mock.On call
//   - ctx context.Context
//   - messageId string
func (_e *MockStoreObject_Expecter) DeleteMessage(ctx interface{}, messageId interface{}) *MockStoreObject_DeleteMessage_Call {
	return &MockStoreObject_DeleteMessage_Call{Call: _e.mock.On("DeleteMessage", ctx, messageId)}
}

func (_c *MockStoreObject_DeleteMessage_Call) Run(run func(ctx context.Context, messageId string)) *MockStoreObject_DeleteMessage_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string))
	})
	return _c
}

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

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

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

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

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

	return r0
}

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

// Details is a helper method to define mock.On call
func (_e *MockStoreObject_Expecter) Details() *MockStoreObject_Details_Call {
	return &MockStoreObject_Details_Call{Call: _e.mock.On("Details")}
}

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

func (_c *MockStoreObject_Details_Call) Return(_a0 *domain.Details) *MockStoreObject_Details_Call {
	_c.Call.Return(_a0)
	return _c
}

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

// EditMessage provides a mock function with given fields: ctx, messageId, newMessage
func (_m *MockStoreObject) EditMessage(ctx context.Context, messageId string, newMessage *chatmodel.Message) error {
	ret := _m.Called(ctx, messageId, newMessage)

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

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

	return r0
}

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

// EditMessage is a helper method to define mock.On call
//   - ctx context.Context
//   - messageId string
//   - newMessage *chatmodel.Message
func (_e *MockStoreObject_Expecter) EditMessage(ctx interface{}, messageId interface{}, newMessage interface{}) *MockStoreObject_EditMessage_Call {
	return &MockStoreObject_EditMessage_Call{Call: _e.mock.On("EditMessage", ctx, messageId, newMessage)}
}

func (_c *MockStoreObject_EditMessage_Call) Run(run func(ctx context.Context, messageId string, newMessage *chatmodel.Message)) *MockStoreObject_EditMessage_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string), args[2].(*chatmodel.Message))
	})
	return _c
}

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

func (_c *MockStoreObject_EditMessage_Call) RunAndReturn(run func(context.Context, string, *chatmodel.Message) error) *MockStoreObject_EditMessage_Call {
	_c.Call.Return(run)
	return _c
}

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

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

// EnableLayouts is a helper method to define mock.On call
func (_e *MockStoreObject_Expecter) EnableLayouts() *MockStoreObject_EnableLayouts_Call {
	return &MockStoreObject_EnableLayouts_Call{Call: _e.mock.On("EnableLayouts")}
}

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

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

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

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

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

// EnabledRelationAsDependentObjects is a helper method to define mock.On call
func (_e *MockStoreObject_Expecter) EnabledRelationAsDependentObjects() *MockStoreObject_EnabledRelationAsDependentObjects_Call {
	return &MockStoreObject_EnabledRelationAsDependentObjects_Call{Call: _e.mock.On("EnabledRelationAsDependentObjects")}
}

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

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

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

// GetAndUnsetFileKeys provides a mock function with given fields:
func (_m *MockStoreObject) GetAndUnsetFileKeys() []pb.ChangeFileKeys {
	ret := _m.Called()

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

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

	return r0
}

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

// GetAndUnsetFileKeys is a helper method to define mock.On call
func (_e *MockStoreObject_Expecter) GetAndUnsetFileKeys() *MockStoreObject_GetAndUnsetFileKeys_Call {
	return &MockStoreObject_GetAndUnsetFileKeys_Call{Call: _e.mock.On("GetAndUnsetFileKeys")}
}

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

func (_c *MockStoreObject_GetAndUnsetFileKeys_Call) Return(_a0 []pb.ChangeFileKeys) *MockStoreObject_GetAndUnsetFileKeys_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockStoreObject_GetAndUnsetFileKeys_Call) RunAndReturn(run func() []pb.ChangeFileKeys) *MockStoreObject_GetAndUnsetFileKeys_Call {
	_c.Call.Return(run)
	return _c
}

// GetDocInfo provides a mock function with given fields:
func (_m *MockStoreObject) GetDocInfo() smartblock.DocInfo {
	ret := _m.Called()

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

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

	return r0
}

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

// GetDocInfo is a helper method to define mock.On call
func (_e *MockStoreObject_Expecter) GetDocInfo() *MockStoreObject_GetDocInfo_Call {
	return &MockStoreObject_GetDocInfo_Call{Call: _e.mock.On("GetDocInfo")}
}

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

func (_c *MockStoreObject_GetDocInfo_Call) Return(_a0 smartblock.DocInfo) *MockStoreObject_GetDocInfo_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockStoreObject_GetDocInfo_Call) RunAndReturn(run func() smartblock.DocInfo) *MockStoreObject_GetDocInfo_Call {
	_c.Call.Return(run)
	return _c
}

// GetMessages provides a mock function with given fields: ctx, req
func (_m *MockStoreObject) GetMessages(ctx context.Context, req chatrepository.GetMessagesRequest) (*chatobject.GetMessagesResponse, error) {
	ret := _m.Called(ctx, req)

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

	var r0 *chatobject.GetMessagesResponse
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, chatrepository.GetMessagesRequest) (*chatobject.GetMessagesResponse, error)); ok {
		return rf(ctx, req)
	}
	if rf, ok := ret.Get(0).(func(context.Context, chatrepository.GetMessagesRequest) *chatobject.GetMessagesResponse); ok {
		r0 = rf(ctx, req)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*chatobject.GetMessagesResponse)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, chatrepository.GetMessagesRequest) error); ok {
		r1 = rf(ctx, req)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// GetMessages is a helper method to define mock.On call
//   - ctx context.Context
//   - req chatrepository.GetMessagesRequest
func (_e *MockStoreObject_Expecter) GetMessages(ctx interface{}, req interface{}) *MockStoreObject_GetMessages_Call {
	return &MockStoreObject_GetMessages_Call{Call: _e.mock.On("GetMessages", ctx, req)}
}

func (_c *MockStoreObject_GetMessages_Call) Run(run func(ctx context.Context, req chatrepository.GetMessagesRequest)) *MockStoreObject_GetMessages_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(chatrepository.GetMessagesRequest))
	})
	return _c
}

func (_c *MockStoreObject_GetMessages_Call) Return(_a0 *chatobject.GetMessagesResponse, _a1 error) *MockStoreObject_GetMessages_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockStoreObject_GetMessages_Call) RunAndReturn(run func(context.Context, chatrepository.GetMessagesRequest) (*chatobject.GetMessagesResponse, error)) *MockStoreObject_GetMessages_Call {
	_c.Call.Return(run)
	return _c
}

// GetMessagesByIds provides a mock function with given fields: ctx, messageIds
func (_m *MockStoreObject) GetMessagesByIds(ctx context.Context, messageIds []string) ([]*chatmodel.Message, error) {
	ret := _m.Called(ctx, messageIds)

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

	var r0 []*chatmodel.Message
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, []string) ([]*chatmodel.Message, error)); ok {
		return rf(ctx, messageIds)
	}
	if rf, ok := ret.Get(0).(func(context.Context, []string) []*chatmodel.Message); ok {
		r0 = rf(ctx, messageIds)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]*chatmodel.Message)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, []string) error); ok {
		r1 = rf(ctx, messageIds)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// GetMessagesByIds is a helper method to define mock.On call
//   - ctx context.Context
//   - messageIds []string
func (_e *MockStoreObject_Expecter) GetMessagesByIds(ctx interface{}, messageIds interface{}) *MockStoreObject_GetMessagesByIds_Call {
	return &MockStoreObject_GetMessagesByIds_Call{Call: _e.mock.On("GetMessagesByIds", ctx, messageIds)}
}

func (_c *MockStoreObject_GetMessagesByIds_Call) Run(run func(ctx context.Context, messageIds []string)) *MockStoreObject_GetMessagesByIds_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].([]string))
	})
	return _c
}

func (_c *MockStoreObject_GetMessagesByIds_Call) Return(_a0 []*chatmodel.Message, _a1 error) *MockStoreObject_GetMessagesByIds_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockStoreObject_GetMessagesByIds_Call) RunAndReturn(run func(context.Context, []string) ([]*chatmodel.Message, error)) *MockStoreObject_GetMessagesByIds_Call {
	_c.Call.Return(run)
	return _c
}

// GetRelationLinks provides a mock function with given fields:
func (_m *MockStoreObject) GetRelationLinks() pbtypes.RelationLinks {
	ret := _m.Called()

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

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

	return r0
}

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

// GetRelationLinks is a helper method to define mock.On call
func (_e *MockStoreObject_Expecter) GetRelationLinks() *MockStoreObject_GetRelationLinks_Call {
	return &MockStoreObject_GetRelationLinks_Call{Call: _e.mock.On("GetRelationLinks")}
}

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

func (_c *MockStoreObject_GetRelationLinks_Call) Return(_a0 pbtypes.RelationLinks) *MockStoreObject_GetRelationLinks_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockStoreObject_GetRelationLinks_Call) RunAndReturn(run func() pbtypes.RelationLinks) *MockStoreObject_GetRelationLinks_Call {
	_c.Call.Return(run)
	return _c
}

// HandleSyncStatusUpdate provides a mock function with given fields: heads, status, syncError
func (_m *MockStoreObject) HandleSyncStatusUpdate(heads []string, status domain.ObjectSyncStatus, syncError domain.SyncError) {
	_m.Called(heads, status, syncError)
}

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

// HandleSyncStatusUpdate is a helper method to define mock.On call
//   - heads []string
//   - status domain.ObjectSyncStatus
//   - syncError domain.SyncError
func (_e *MockStoreObject_Expecter) HandleSyncStatusUpdate(heads interface{}, status interface{}, syncError interface{}) *MockStoreObject_HandleSyncStatusUpdate_Call {
	return &MockStoreObject_HandleSyncStatusUpdate_Call{Call: _e.mock.On("HandleSyncStatusUpdate", heads, status, syncError)}
}

func (_c *MockStoreObject_HandleSyncStatusUpdate_Call) Run(run func(heads []string, status domain.ObjectSyncStatus, syncError domain.SyncError)) *MockStoreObject_HandleSyncStatusUpdate_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].([]string), args[1].(domain.ObjectSyncStatus), args[2].(domain.SyncError))
	})
	return _c
}

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

func (_c *MockStoreObject_HandleSyncStatusUpdate_Call) RunAndReturn(run func([]string, domain.ObjectSyncStatus, domain.SyncError)) *MockStoreObject_HandleSyncStatusUpdate_Call {
	_c.Call.Return(run)
	return _c
}

// HasRelation provides a mock function with given fields: s, relationKey
func (_m *MockStoreObject) HasRelation(s *state.State, relationKey string) bool {
	ret := _m.Called(s, relationKey)

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

	var r0 bool
	if rf, ok := ret.Get(0).(func(*state.State, string) bool); ok {
		r0 = rf(s, relationKey)
	} else {
		r0 = ret.Get(0).(bool)
	}

	return r0
}

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

// HasRelation is a helper method to define mock.On call
//   - s *state.State
//   - relationKey string
func (_e *MockStoreObject_Expecter) HasRelation(s interface{}, relationKey interface{}) *MockStoreObject_HasRelation_Call {
	return &MockStoreObject_HasRelation_Call{Call: _e.mock.On("HasRelation", s, relationKey)}
}

func (_c *MockStoreObject_HasRelation_Call) Run(run func(s *state.State, relationKey string)) *MockStoreObject_HasRelation_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(*state.State), args[1].(string))
	})
	return _c
}

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

func (_c *MockStoreObject_HasRelation_Call) RunAndReturn(run func(*state.State, string) bool) *MockStoreObject_HasRelation_Call {
	_c.Call.Return(run)
	return _c
}

// History provides a mock function with given fields:
func (_m *MockStoreObject) History() undo.History {
	ret := _m.Called()

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

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

	return r0
}

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

// History is a helper method to define mock.On call
func (_e *MockStoreObject_Expecter) History() *MockStoreObject_History_Call {
	return &MockStoreObject_History_Call{Call: _e.mock.On("History")}
}

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

func (_c *MockStoreObject_History_Call) Return(_a0 undo.History) *MockStoreObject_History_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockStoreObject_History_Call) RunAndReturn(run func() undo.History) *MockStoreObject_History_Call {
	_c.Call.Return(run)
	return _c
}

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

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

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

	return r0
}

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

// Id is a helper method to define mock.On call
func (_e *MockStoreObject_Expecter) Id() *MockStoreObject_Id_Call {
	return &MockStoreObject_Id_Call{Call: _e.mock.On("Id")}
}

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

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

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

// Init provides a mock function with given fields: ctx
func (_m *MockStoreObject) Init(ctx *smartblock.InitContext) error {
	ret := _m.Called(ctx)

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

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

	return r0
}

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

// Init is a helper method to define mock.On call
//   - ctx *smartblock.InitContext
func (_e *MockStoreObject_Expecter) Init(ctx interface{}) *MockStoreObject_Init_Call {
	return &MockStoreObject_Init_Call{Call: _e.mock.On("Init", ctx)}
}

func (_c *MockStoreObject_Init_Call) Run(run func(ctx *smartblock.InitContext)) *MockStoreObject_Init_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(*smartblock.InitContext))
	})
	return _c
}

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

func (_c *MockStoreObject_Init_Call) RunAndReturn(run func(*smartblock.InitContext) error) *MockStoreObject_Init_Call {
	_c.Call.Return(run)
	return _c
}

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

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

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

	return r0
}

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

// IsDeleted is a helper method to define mock.On call
func (_e *MockStoreObject_Expecter) IsDeleted() *MockStoreObject_IsDeleted_Call {
	return &MockStoreObject_IsDeleted_Call{Call: _e.mock.On("IsDeleted")}
}

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

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

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

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

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

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

	return r0
}

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

// IsLocked is a helper method to define mock.On call
func (_e *MockStoreObject_Expecter) IsLocked() *MockStoreObject_IsLocked_Call {
	return &MockStoreObject_IsLocked_Call{Call: _e.mock.On("IsLocked")}
}

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

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

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

// Iterate provides a mock function with given fields: f
func (_m *MockStoreObject) Iterate(f func(simple.Block) bool) error {
	ret := _m.Called(f)

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

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

	return r0
}

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

// Iterate is a helper method to define mock.On call
//   - f func(simple.Block) bool
func (_e *MockStoreObject_Expecter) Iterate(f interface{}) *MockStoreObject_Iterate_Call {
	return &MockStoreObject_Iterate_Call{Call: _e.mock.On("Iterate", f)}
}

func (_c *MockStoreObject_Iterate_Call) Run(run func(f func(simple.Block) bool)) *MockStoreObject_Iterate_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(func(simple.Block) bool))
	})
	return _c
}

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

func (_c *MockStoreObject_Iterate_Call) RunAndReturn(run func(func(simple.Block) bool) error) *MockStoreObject_Iterate_Call {
	_c.Call.Return(run)
	return _c
}

// Layout provides a mock function with given fields:
func (_m *MockStoreObject) Layout() (model.ObjectTypeLayout, bool) {
	ret := _m.Called()

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

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

	if rf, ok := ret.Get(1).(func() bool); ok {
		r1 = rf()
	} else {
		r1 = ret.Get(1).(bool)
	}

	return r0, r1
}

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

// Layout is a helper method to define mock.On call
func (_e *MockStoreObject_Expecter) Layout() *MockStoreObject_Layout_Call {
	return &MockStoreObject_Layout_Call{Call: _e.mock.On("Layout")}
}

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

func (_c *MockStoreObject_Layout_Call) Return(_a0 model.ObjectTypeLayout, _a1 bool) *MockStoreObject_Layout_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockStoreObject_Layout_Call) RunAndReturn(run func() (model.ObjectTypeLayout, bool)) *MockStoreObject_Layout_Call {
	_c.Call.Return(run)
	return _c
}

// LocalDetails provides a mock function with given fields:
func (_m *MockStoreObject) LocalDetails() *domain.Details {
	ret := _m.Called()

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

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

	return r0
}

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

// LocalDetails is a helper method to define mock.On call
func (_e *MockStoreObject_Expecter) LocalDetails() *MockStoreObject_LocalDetails_Call {
	return &MockStoreObject_LocalDetails_Call{Call: _e.mock.On("LocalDetails")}
}

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

func (_c *MockStoreObject_LocalDetails_Call) Return(_a0 *domain.Details) *MockStoreObject_LocalDetails_Call {
	_c.Call.Return(_a0)
	return _c
}

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

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

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

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

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

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

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

// MarkMessagesAsUnread provides a mock function with given fields: ctx, afterOrderId, counterType
func (_m *MockStoreObject) MarkMessagesAsUnread(ctx context.Context, afterOrderId string, counterType chatmodel.CounterType) error {
	ret := _m.Called(ctx, afterOrderId, counterType)

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

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

	return r0
}

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

// MarkMessagesAsUnread is a helper method to define mock.On call
//   - ctx context.Context
//   - afterOrderId string
//   - counterType chatmodel.CounterType
func (_e *MockStoreObject_Expecter) MarkMessagesAsUnread(ctx interface{}, afterOrderId interface{}, counterType interface{}) *MockStoreObject_MarkMessagesAsUnread_Call {
	return &MockStoreObject_MarkMessagesAsUnread_Call{Call: _e.mock.On("MarkMessagesAsUnread", ctx, afterOrderId, counterType)}
}

func (_c *MockStoreObject_MarkMessagesAsUnread_Call) Run(run func(ctx context.Context, afterOrderId string, counterType chatmodel.CounterType)) *MockStoreObject_MarkMessagesAsUnread_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string), args[2].(chatmodel.CounterType))
	})
	return _c
}

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

func (_c *MockStoreObject_MarkMessagesAsUnread_Call) RunAndReturn(run func(context.Context, string, chatmodel.CounterType) error) *MockStoreObject_MarkMessagesAsUnread_Call {
	_c.Call.Return(run)
	return _c
}

// MarkReadMessages provides a mock function with given fields: ctx, req
func (_m *MockStoreObject) MarkReadMessages(ctx context.Context, req chatobject.ReadMessagesRequest) (int, error) {
	ret := _m.Called(ctx, req)

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

	var r0 int
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, chatobject.ReadMessagesRequest) (int, error)); ok {
		return rf(ctx, req)
	}
	if rf, ok := ret.Get(0).(func(context.Context, chatobject.ReadMessagesRequest) int); ok {
		r0 = rf(ctx, req)
	} else {
		r0 = ret.Get(0).(int)
	}

	if rf, ok := ret.Get(1).(func(context.Context, chatobject.ReadMessagesRequest) error); ok {
		r1 = rf(ctx, req)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// MarkReadMessages is a helper method to define mock.On call
//   - ctx context.Context
//   - req chatobject.ReadMessagesRequest
func (_e *MockStoreObject_Expecter) MarkReadMessages(ctx interface{}, req interface{}) *MockStoreObject_MarkReadMessages_Call {
	return &MockStoreObject_MarkReadMessages_Call{Call: _e.mock.On("MarkReadMessages", ctx, req)}
}

func (_c *MockStoreObject_MarkReadMessages_Call) Run(run func(ctx context.Context, req chatobject.ReadMessagesRequest)) *MockStoreObject_MarkReadMessages_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(chatobject.ReadMessagesRequest))
	})
	return _c
}

func (_c *MockStoreObject_MarkReadMessages_Call) Return(markedCount int, err error) *MockStoreObject_MarkReadMessages_Call {
	_c.Call.Return(markedCount, err)
	return _c
}

func (_c *MockStoreObject_MarkReadMessages_Call) RunAndReturn(run func(context.Context, chatobject.ReadMessagesRequest) (int, error)) *MockStoreObject_MarkReadMessages_Call {
	_c.Call.Return(run)
	return _c
}

// NewState provides a mock function with given fields:
func (_m *MockStoreObject) NewState() *state.State {
	ret := _m.Called()

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

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

	return r0
}

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

// NewState is a helper method to define mock.On call
func (_e *MockStoreObject_Expecter) NewState() *MockStoreObject_NewState_Call {
	return &MockStoreObject_NewState_Call{Call: _e.mock.On("NewState")}
}

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

func (_c *MockStoreObject_NewState_Call) Return(_a0 *state.State) *MockStoreObject_NewState_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockStoreObject_NewState_Call) RunAndReturn(run func() *state.State) *MockStoreObject_NewState_Call {
	_c.Call.Return(run)
	return _c
}

// NewStateCtx provides a mock function with given fields: ctx
func (_m *MockStoreObject) NewStateCtx(ctx session.Context) *state.State {
	ret := _m.Called(ctx)

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

	var r0 *state.State
	if rf, ok := ret.Get(0).(func(session.Context) *state.State); ok {
		r0 = rf(ctx)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*state.State)
		}
	}

	return r0
}

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

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

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

func (_c *MockStoreObject_NewStateCtx_Call) Return(_a0 *state.State) *MockStoreObject_NewStateCtx_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockStoreObject_NewStateCtx_Call) RunAndReturn(run func(session.Context) *state.State) *MockStoreObject_NewStateCtx_Call {
	_c.Call.Return(run)
	return _c
}

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

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

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

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

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

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

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

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

// ObjectCloseAllSessions is a helper method to define mock.On call
func (_e *MockStoreObject_Expecter) ObjectCloseAllSessions() *MockStoreObject_ObjectCloseAllSessions_Call {
	return &MockStoreObject_ObjectCloseAllSessions_Call{Call: _e.mock.On("ObjectCloseAllSessions")}
}

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

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

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

// ObjectTypeKey provides a mock function with given fields:
func (_m *MockStoreObject) ObjectTypeKey() domain.TypeKey {
	ret := _m.Called()

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

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

	return r0
}

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

// ObjectTypeKey is a helper method to define mock.On call
func (_e *MockStoreObject_Expecter) ObjectTypeKey() *MockStoreObject_ObjectTypeKey_Call {
	return &MockStoreObject_ObjectTypeKey_Call{Call: _e.mock.On("ObjectTypeKey")}
}

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

func (_c *MockStoreObject_ObjectTypeKey_Call) Return(_a0 domain.TypeKey) *MockStoreObject_ObjectTypeKey_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockStoreObject_ObjectTypeKey_Call) RunAndReturn(run func() domain.TypeKey) *MockStoreObject_ObjectTypeKey_Call {
	_c.Call.Return(run)
	return _c
}

// ObjectTypeKeys provides a mock function with given fields:
func (_m *MockStoreObject) ObjectTypeKeys() []domain.TypeKey {
	ret := _m.Called()

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

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

	return r0
}

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

// ObjectTypeKeys is a helper method to define mock.On call
func (_e *MockStoreObject_Expecter) ObjectTypeKeys() *MockStoreObject_ObjectTypeKeys_Call {
	return &MockStoreObject_ObjectTypeKeys_Call{Call: _e.mock.On("ObjectTypeKeys")}
}

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

func (_c *MockStoreObject_ObjectTypeKeys_Call) Return(_a0 []domain.TypeKey) *MockStoreObject_ObjectTypeKeys_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockStoreObject_ObjectTypeKeys_Call) RunAndReturn(run func() []domain.TypeKey) *MockStoreObject_ObjectTypeKeys_Call {
	_c.Call.Return(run)
	return _c
}

// Pick provides a mock function with given fields: id
func (_m *MockStoreObject) Pick(id string) simple.Block {
	ret := _m.Called(id)

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

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

	return r0
}

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

// Pick is a helper method to define mock.On call
//   - id string
func (_e *MockStoreObject_Expecter) Pick(id interface{}) *MockStoreObject_Pick_Call {
	return &MockStoreObject_Pick_Call{Call: _e.mock.On("Pick", id)}
}

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

func (_c *MockStoreObject_Pick_Call) Return(b simple.Block) *MockStoreObject_Pick_Call {
	_c.Call.Return(b)
	return _c
}

func (_c *MockStoreObject_Pick_Call) RunAndReturn(run func(string) simple.Block) *MockStoreObject_Pick_Call {
	_c.Call.Return(run)
	return _c
}

// RegisterSession provides a mock function with given fields: _a0
func (_m *MockStoreObject) RegisterSession(_a0 session.Context) {
	_m.Called(_a0)
}

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

// RegisterSession is a helper method to define mock.On call
//   - _a0 session.Context
func (_e *MockStoreObject_Expecter) RegisterSession(_a0 interface{}) *MockStoreObject_RegisterSession_Call {
	return &MockStoreObject_RegisterSession_Call{Call: _e.mock.On("RegisterSession", _a0)}
}

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

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

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

// Relations provides a mock function with given fields: s
func (_m *MockStoreObject) Relations(s *state.State) relationutils.Relations {
	ret := _m.Called(s)

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

	var r0 relationutils.Relations
	if rf, ok := ret.Get(0).(func(*state.State) relationutils.Relations); ok {
		r0 = rf(s)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(relationutils.Relations)
		}
	}

	return r0
}

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

// Relations is a helper method to define mock.On call
//   - s *state.State
func (_e *MockStoreObject_Expecter) Relations(s interface{}) *MockStoreObject_Relations_Call {
	return &MockStoreObject_Relations_Call{Call: _e.mock.On("Relations", s)}
}

func (_c *MockStoreObject_Relations_Call) Run(run func(s *state.State)) *MockStoreObject_Relations_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(*state.State))
	})
	return _c
}

func (_c *MockStoreObject_Relations_Call) Return(_a0 relationutils.Relations) *MockStoreObject_Relations_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockStoreObject_Relations_Call) RunAndReturn(run func(*state.State) relationutils.Relations) *MockStoreObject_Relations_Call {
	_c.Call.Return(run)
	return _c
}

// RemoveExtraRelations provides a mock function with given fields: ctx, relationKeys
func (_m *MockStoreObject) RemoveExtraRelations(ctx session.Context, relationKeys []domain.RelationKey) error {
	ret := _m.Called(ctx, relationKeys)

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

	var r0 error
	if rf, ok := ret.Get(0).(func(session.Context, []domain.RelationKey) error); ok {
		r0 = rf(ctx, relationKeys)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

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

// RemoveExtraRelations is a helper method to define mock.On call
//   - ctx session.Context
//   - relationKeys []domain.RelationKey
func (_e *MockStoreObject_Expecter) RemoveExtraRelations(ctx interface{}, relationKeys interface{}) *MockStoreObject_RemoveExtraRelations_Call {
	return &MockStoreObject_RemoveExtraRelations_Call{Call: _e.mock.On("RemoveExtraRelations", ctx, relationKeys)}
}

func (_c *MockStoreObject_RemoveExtraRelations_Call) Run(run func(ctx session.Context, relationKeys []domain.RelationKey)) *MockStoreObject_RemoveExtraRelations_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(session.Context), args[1].([]domain.RelationKey))
	})
	return _c
}

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

func (_c *MockStoreObject_RemoveExtraRelations_Call) RunAndReturn(run func(session.Context, []domain.RelationKey) error) *MockStoreObject_RemoveExtraRelations_Call {
	_c.Call.Return(run)
	return _c
}

// ResetToVersion provides a mock function with given fields: s
func (_m *MockStoreObject) ResetToVersion(s *state.State) error {
	ret := _m.Called(s)

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

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

	return r0
}

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

// ResetToVersion is a helper method to define mock.On call
//   - s *state.State
func (_e *MockStoreObject_Expecter) ResetToVersion(s interface{}) *MockStoreObject_ResetToVersion_Call {
	return &MockStoreObject_ResetToVersion_Call{Call: _e.mock.On("ResetToVersion", s)}
}

func (_c *MockStoreObject_ResetToVersion_Call) Run(run func(s *state.State)) *MockStoreObject_ResetToVersion_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(*state.State))
	})
	return _c
}

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

func (_c *MockStoreObject_ResetToVersion_Call) RunAndReturn(run func(*state.State) error) *MockStoreObject_ResetToVersion_Call {
	_c.Call.Return(run)
	return _c
}

// Restrictions provides a mock function with given fields:
func (_m *MockStoreObject) Restrictions() restriction.Restrictions {
	ret := _m.Called()

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

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

	return r0
}

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

// Restrictions is a helper method to define mock.On call
func (_e *MockStoreObject_Expecter) Restrictions() *MockStoreObject_Restrictions_Call {
	return &MockStoreObject_Restrictions_Call{Call: _e.mock.On("Restrictions")}
}

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

func (_c *MockStoreObject_Restrictions_Call) Return(_a0 restriction.Restrictions) *MockStoreObject_Restrictions_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockStoreObject_Restrictions_Call) RunAndReturn(run func() restriction.Restrictions) *MockStoreObject_Restrictions_Call {
	_c.Call.Return(run)
	return _c
}

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

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

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

	return r0
}

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

// RootId is a helper method to define mock.On call
func (_e *MockStoreObject_Expecter) RootId() *MockStoreObject_RootId_Call {
	return &MockStoreObject_RootId_Call{Call: _e.mock.On("RootId")}
}

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

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

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

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

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

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

	return r0
}

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

// SearchText is a helper method to define mock.On call
func (_e *MockStoreObject_Expecter) SearchText() *MockStoreObject_SearchText_Call {
	return &MockStoreObject_SearchText_Call{Call: _e.mock.On("SearchText")}
}

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

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

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

// SendEvent provides a mock function with given fields: msgs
func (_m *MockStoreObject) SendEvent(msgs []*pb.EventMessage) {
	_m.Called(msgs)
}

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

// SendEvent is a helper method to define mock.On call
//   - msgs []*pb.EventMessage
func (_e *MockStoreObject_Expecter) SendEvent(msgs interface{}) *MockStoreObject_SendEvent_Call {
	return &MockStoreObject_SendEvent_Call{Call: _e.mock.On("SendEvent", msgs)}
}

func (_c *MockStoreObject_SendEvent_Call) Run(run func(msgs []*pb.EventMessage)) *MockStoreObject_SendEvent_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].([]*pb.EventMessage))
	})
	return _c
}

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

func (_c *MockStoreObject_SendEvent_Call) RunAndReturn(run func([]*pb.EventMessage)) *MockStoreObject_SendEvent_Call {
	_c.Call.Return(run)
	return _c
}

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

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

// SetIsDeleted is a helper method to define mock.On call
func (_e *MockStoreObject_Expecter) SetIsDeleted() *MockStoreObject_SetIsDeleted_Call {
	return &MockStoreObject_SetIsDeleted_Call{Call: _e.mock.On("SetIsDeleted")}
}

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

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

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

// SetLocker provides a mock function with given fields: locker
func (_m *MockStoreObject) SetLocker(locker smartblock.Locker) {
	_m.Called(locker)
}

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

// SetLocker is a helper method to define mock.On call
//   - locker smartblock.Locker
func (_e *MockStoreObject_Expecter) SetLocker(locker interface{}) *MockStoreObject_SetLocker_Call {
	return &MockStoreObject_SetLocker_Call{Call: _e.mock.On("SetLocker", locker)}
}

func (_c *MockStoreObject_SetLocker_Call) Run(run func(locker smartblock.Locker)) *MockStoreObject_SetLocker_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(smartblock.Locker))
	})
	return _c
}

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

func (_c *MockStoreObject_SetLocker_Call) RunAndReturn(run func(smartblock.Locker)) *MockStoreObject_SetLocker_Call {
	_c.Call.Return(run)
	return _c
}

// SetVerticalAlign provides a mock function with given fields: ctx, align, ids
func (_m *MockStoreObject) SetVerticalAlign(ctx session.Context, align model.BlockVerticalAlign, ids ...string) error {
	_va := make([]interface{}, len(ids))
	for _i := range ids {
		_va[_i] = ids[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, align)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

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

	var r0 error
	if rf, ok := ret.Get(0).(func(session.Context, model.BlockVerticalAlign, ...string) error); ok {
		r0 = rf(ctx, align, ids...)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

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

// SetVerticalAlign is a helper method to define mock.On call
//   - ctx session.Context
//   - align model.BlockVerticalAlign
//   - ids ...string
func (_e *MockStoreObject_Expecter) SetVerticalAlign(ctx interface{}, align interface{}, ids ...interface{}) *MockStoreObject_SetVerticalAlign_Call {
	return &MockStoreObject_SetVerticalAlign_Call{Call: _e.mock.On("SetVerticalAlign",
		append([]interface{}{ctx, align}, ids...)...)}
}

func (_c *MockStoreObject_SetVerticalAlign_Call) Run(run func(ctx session.Context, align model.BlockVerticalAlign, ids ...string)) *MockStoreObject_SetVerticalAlign_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]string, len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(string)
			}
		}
		run(args[0].(session.Context), args[1].(model.BlockVerticalAlign), variadicArgs...)
	})
	return _c
}

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

func (_c *MockStoreObject_SetVerticalAlign_Call) RunAndReturn(run func(session.Context, model.BlockVerticalAlign, ...string) error) *MockStoreObject_SetVerticalAlign_Call {
	_c.Call.Return(run)
	return _c
}

// Show provides a mock function with given fields:
func (_m *MockStoreObject) Show() (*model.ObjectView, error) {
	ret := _m.Called()

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

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

	if rf, ok := ret.Get(1).(func() error); ok {
		r1 = rf()
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// Show is a helper method to define mock.On call
func (_e *MockStoreObject_Expecter) Show() *MockStoreObject_Show_Call {
	return &MockStoreObject_Show_Call{Call: _e.mock.On("Show")}
}

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

func (_c *MockStoreObject_Show_Call) Return(obj *model.ObjectView, err error) *MockStoreObject_Show_Call {
	_c.Call.Return(obj, err)
	return _c
}

func (_c *MockStoreObject_Show_Call) RunAndReturn(run func() (*model.ObjectView, error)) *MockStoreObject_Show_Call {
	_c.Call.Return(run)
	return _c
}

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

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

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

	return r0
}

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

// Snippet is a helper method to define mock.On call
func (_e *MockStoreObject_Expecter) Snippet() *MockStoreObject_Snippet_Call {
	return &MockStoreObject_Snippet_Call{Call: _e.mock.On("Snippet")}
}

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

func (_c *MockStoreObject_Snippet_Call) Return(snippet string) *MockStoreObject_Snippet_Call {
	_c.Call.Return(snippet)
	return _c
}

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

// Space provides a mock function with given fields:
func (_m *MockStoreObject) Space() smartblock.Space {
	ret := _m.Called()

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

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

	return r0
}

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

// Space is a helper method to define mock.On call
func (_e *MockStoreObject_Expecter) Space() *MockStoreObject_Space_Call {
	return &MockStoreObject_Space_Call{Call: _e.mock.On("Space")}
}

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

func (_c *MockStoreObject_Space_Call) Return(_a0 smartblock.Space) *MockStoreObject_Space_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockStoreObject_Space_Call) RunAndReturn(run func() smartblock.Space) *MockStoreObject_Space_Call {
	_c.Call.Return(run)
	return _c
}

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

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

// SpaceID is a helper method to define mock.On call
func (_e *MockStoreObject_Expecter) SpaceID() *MockStoreObject_SpaceID_Call {
	return &MockStoreObject_SpaceID_Call{Call: _e.mock.On("SpaceID")}
}

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

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

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

// ToggleMessageReaction provides a mock function with given fields: ctx, messageId, emoji
func (_m *MockStoreObject) ToggleMessageReaction(ctx context.Context, messageId string, emoji string) (bool, error) {
	ret := _m.Called(ctx, messageId, emoji)

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

	var r0 bool
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, string, string) (bool, error)); ok {
		return rf(ctx, messageId, emoji)
	}
	if rf, ok := ret.Get(0).(func(context.Context, string, string) bool); ok {
		r0 = rf(ctx, messageId, emoji)
	} else {
		r0 = ret.Get(0).(bool)
	}

	if rf, ok := ret.Get(1).(func(context.Context, string, string) error); ok {
		r1 = rf(ctx, messageId, emoji)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// ToggleMessageReaction is a helper method to define mock.On call
//   - ctx context.Context
//   - messageId string
//   - emoji string
func (_e *MockStoreObject_Expecter) ToggleMessageReaction(ctx interface{}, messageId interface{}, emoji interface{}) *MockStoreObject_ToggleMessageReaction_Call {
	return &MockStoreObject_ToggleMessageReaction_Call{Call: _e.mock.On("ToggleMessageReaction", ctx, messageId, emoji)}
}

func (_c *MockStoreObject_ToggleMessageReaction_Call) Run(run func(ctx context.Context, messageId string, emoji string)) *MockStoreObject_ToggleMessageReaction_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string), args[2].(string))
	})
	return _c
}

func (_c *MockStoreObject_ToggleMessageReaction_Call) Return(_a0 bool, _a1 error) *MockStoreObject_ToggleMessageReaction_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockStoreObject_ToggleMessageReaction_Call) RunAndReturn(run func(context.Context, string, string) (bool, error)) *MockStoreObject_ToggleMessageReaction_Call {
	_c.Call.Return(run)
	return _c
}

// Tree provides a mock function with given fields:
func (_m *MockStoreObject) Tree() objecttree.ObjectTree {
	ret := _m.Called()

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

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

	return r0
}

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

// Tree is a helper method to define mock.On call
func (_e *MockStoreObject_Expecter) Tree() *MockStoreObject_Tree_Call {
	return &MockStoreObject_Tree_Call{Call: _e.mock.On("Tree")}
}

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

func (_c *MockStoreObject_Tree_Call) Return(_a0 objecttree.ObjectTree) *MockStoreObject_Tree_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockStoreObject_Tree_Call) RunAndReturn(run func() objecttree.ObjectTree) *MockStoreObject_Tree_Call {
	_c.Call.Return(run)
	return _c
}

// TryClose provides a mock function with given fields: objectTTL
func (_m *MockStoreObject) TryClose(objectTTL time.Duration) (bool, error) {
	ret := _m.Called(objectTTL)

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

	var r0 bool
	var r1 error
	if rf, ok := ret.Get(0).(func(time.Duration) (bool, error)); ok {
		return rf(objectTTL)
	}
	if rf, ok := ret.Get(0).(func(time.Duration) bool); ok {
		r0 = rf(objectTTL)
	} else {
		r0 = ret.Get(0).(bool)
	}

	if rf, ok := ret.Get(1).(func(time.Duration) error); ok {
		r1 = rf(objectTTL)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// TryClose is a helper method to define mock.On call
//   - objectTTL time.Duration
func (_e *MockStoreObject_Expecter) TryClose(objectTTL interface{}) *MockStoreObject_TryClose_Call {
	return &MockStoreObject_TryClose_Call{Call: _e.mock.On("TryClose", objectTTL)}
}

func (_c *MockStoreObject_TryClose_Call) Run(run func(objectTTL time.Duration)) *MockStoreObject_TryClose_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(time.Duration))
	})
	return _c
}

func (_c *MockStoreObject_TryClose_Call) Return(res bool, err error) *MockStoreObject_TryClose_Call {
	_c.Call.Return(res, err)
	return _c
}

func (_c *MockStoreObject_TryClose_Call) RunAndReturn(run func(time.Duration) (bool, error)) *MockStoreObject_TryClose_Call {
	_c.Call.Return(run)
	return _c
}

// Type provides a mock function with given fields:
func (_m *MockStoreObject) Type() coresmartblock.SmartBlockType {
	ret := _m.Called()

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

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

	return r0
}

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

// Type is a helper method to define mock.On call
func (_e *MockStoreObject_Expecter) Type() *MockStoreObject_Type_Call {
	return &MockStoreObject_Type_Call{Call: _e.mock.On("Type")}
}

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

func (_c *MockStoreObject_Type_Call) Return(_a0 coresmartblock.SmartBlockType) *MockStoreObject_Type_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockStoreObject_Type_Call) RunAndReturn(run func() coresmartblock.SmartBlockType) *MockStoreObject_Type_Call {
	_c.Call.Return(run)
	return _c
}

// UniqueKey provides a mock function with given fields:
func (_m *MockStoreObject) UniqueKey() domain.UniqueKey {
	ret := _m.Called()

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

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

	return r0
}

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

// UniqueKey is a helper method to define mock.On call
func (_e *MockStoreObject_Expecter) UniqueKey() *MockStoreObject_UniqueKey_Call {
	return &MockStoreObject_UniqueKey_Call{Call: _e.mock.On("UniqueKey")}
}

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

func (_c *MockStoreObject_UniqueKey_Call) Return(_a0 domain.UniqueKey) *MockStoreObject_UniqueKey_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockStoreObject_UniqueKey_Call) RunAndReturn(run func() domain.UniqueKey) *MockStoreObject_UniqueKey_Call {
	_c.Call.Return(run)
	return _c
}

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

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

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

	return r0
}

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

// UniqueKeyInternal is a helper method to define mock.On call
func (_e *MockStoreObject_Expecter) UniqueKeyInternal() *MockStoreObject_UniqueKeyInternal_Call {
	return &MockStoreObject_UniqueKeyInternal_Call{Call: _e.mock.On("UniqueKeyInternal")}
}

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

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

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

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

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

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

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

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

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

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

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

	return mock
}
