// Code generated by mockery. DO NOT EDIT.

package mock_techspace

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

	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"
)

// MockAccountObject is an autogenerated mock type for the AccountObject type
type MockAccountObject struct {
	mock.Mock
}

type MockAccountObject_Expecter struct {
	mock *mock.Mock
}

func (_m *MockAccountObject) EXPECT() *MockAccountObject_Expecter {
	return &MockAccountObject_Expecter{mock: &_m.Mock}
}

// AddHook provides a mock function with given fields: f, events
func (_m *MockAccountObject) 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...)
}

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

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

func (_c *MockAccountObject_AddHook_Call) Run(run func(f smartblock.HookCallback, events ...smartblock.Hook)) *MockAccountObject_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 *MockAccountObject_AddHook_Call) Return() *MockAccountObject_AddHook_Call {
	_c.Call.Return()
	return _c
}

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

// AddHookOnce provides a mock function with given fields: id, f, events
func (_m *MockAccountObject) 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...)
}

// MockAccountObject_AddHookOnce_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AddHookOnce'
type MockAccountObject_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 *MockAccountObject_Expecter) AddHookOnce(id interface{}, f interface{}, events ...interface{}) *MockAccountObject_AddHookOnce_Call {
	return &MockAccountObject_AddHookOnce_Call{Call: _e.mock.On("AddHookOnce",
		append([]interface{}{id, f}, events...)...)}
}

func (_c *MockAccountObject_AddHookOnce_Call) Run(run func(id string, f smartblock.HookCallback, events ...smartblock.Hook)) *MockAccountObject_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 *MockAccountObject_AddHookOnce_Call) Return() *MockAccountObject_AddHookOnce_Call {
	_c.Call.Return()
	return _c
}

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

// AddRelationLinksToState provides a mock function with given fields: s, relationKeys
func (_m *MockAccountObject) 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
}

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

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

func (_c *MockAccountObject_AddRelationLinksToState_Call) Run(run func(s *state.State, relationKeys ...domain.RelationKey)) *MockAccountObject_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 *MockAccountObject_AddRelationLinksToState_Call) Return(err error) *MockAccountObject_AddRelationLinksToState_Call {
	_c.Call.Return(err)
	return _c
}

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

// Apply provides a mock function with given fields: s, flags
func (_m *MockAccountObject) 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
}

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

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

func (_c *MockAccountObject_Apply_Call) Run(run func(s *state.State, flags ...smartblock.ApplyFlag)) *MockAccountObject_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 *MockAccountObject_Apply_Call) Return(_a0 error) *MockAccountObject_Apply_Call {
	_c.Call.Return(_a0)
	return _c
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

// GetAnalyticsId provides a mock function with given fields:
func (_m *MockAccountObject) GetAnalyticsId() (string, error) {
	ret := _m.Called()

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

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

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

	return r0, r1
}

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

// GetAnalyticsId is a helper method to define mock.On call
func (_e *MockAccountObject_Expecter) GetAnalyticsId() *MockAccountObject_GetAnalyticsId_Call {
	return &MockAccountObject_GetAnalyticsId_Call{Call: _e.mock.On("GetAnalyticsId")}
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

// HasRelation provides a mock function with given fields: s, relationKey
func (_m *MockAccountObject) 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
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

// IsIconMigrated provides a mock function with given fields:
func (_m *MockAccountObject) IsIconMigrated() (bool, error) {
	ret := _m.Called()

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

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

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

	return r0, r1
}

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

// IsIconMigrated is a helper method to define mock.On call
func (_e *MockAccountObject_Expecter) IsIconMigrated() *MockAccountObject_IsIconMigrated_Call {
	return &MockAccountObject_IsIconMigrated_Call{Call: _e.mock.On("IsIconMigrated")}
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

// MigrateIconImage provides a mock function with given fields: image
func (_m *MockAccountObject) MigrateIconImage(image string) error {
	ret := _m.Called(image)

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

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

	return r0
}

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

// MigrateIconImage is a helper method to define mock.On call
//   - image string
func (_e *MockAccountObject_Expecter) MigrateIconImage(image interface{}) *MockAccountObject_MigrateIconImage_Call {
	return &MockAccountObject_MigrateIconImage_Call{Call: _e.mock.On("MigrateIconImage", image)}
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

// SetAnalyticsId provides a mock function with given fields: analyticsId
func (_m *MockAccountObject) SetAnalyticsId(analyticsId string) error {
	ret := _m.Called(analyticsId)

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

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

	return r0
}

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

// SetAnalyticsId is a helper method to define mock.On call
//   - analyticsId string
func (_e *MockAccountObject_Expecter) SetAnalyticsId(analyticsId interface{}) *MockAccountObject_SetAnalyticsId_Call {
	return &MockAccountObject_SetAnalyticsId_Call{Call: _e.mock.On("SetAnalyticsId", analyticsId)}
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

	return r0
}

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

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

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

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

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

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

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

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

	return r0
}

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

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

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

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

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

// SetVerticalAlign provides a mock function with given fields: ctx, align, ids
func (_m *MockAccountObject) 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
}

// MockAccountObject_SetVerticalAlign_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetVerticalAlign'
type MockAccountObject_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 *MockAccountObject_Expecter) SetVerticalAlign(ctx interface{}, align interface{}, ids ...interface{}) *MockAccountObject_SetVerticalAlign_Call {
	return &MockAccountObject_SetVerticalAlign_Call{Call: _e.mock.On("SetVerticalAlign",
		append([]interface{}{ctx, align}, ids...)...)}
}

func (_c *MockAccountObject_SetVerticalAlign_Call) Run(run func(ctx session.Context, align model.BlockVerticalAlign, ids ...string)) *MockAccountObject_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 *MockAccountObject_SetVerticalAlign_Call) Return(_a0 error) *MockAccountObject_SetVerticalAlign_Call {
	_c.Call.Return(_a0)
	return _c
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

	return mock
}
