// Code generated by MockGen. DO NOT EDIT.
// Source: github.com/anyproto/any-sync-node/nodestorage (interfaces: NodeStorage,IndexStorage)
//
// Generated by this command:
//
//	mockgen -destination mock_nodestorage/mock_nodestorage.go github.com/anyproto/any-sync-node/nodestorage NodeStorage,IndexStorage
//

// Package mock_nodestorage is a generated GoMock package.
package mock_nodestorage

import (
	context "context"
	reflect "reflect"
	time "time"

	nodestorage "github.com/anyproto/any-sync-node/nodestorage"
	app "github.com/anyproto/any-sync/app"
	spacestorage "github.com/anyproto/any-sync/commonspace/spacestorage"
	gomock "go.uber.org/mock/gomock"
)

// MockNodeStorage is a mock of NodeStorage interface.
type MockNodeStorage struct {
	ctrl     *gomock.Controller
	recorder *MockNodeStorageMockRecorder
	isgomock struct{}
}

// MockNodeStorageMockRecorder is the mock recorder for MockNodeStorage.
type MockNodeStorageMockRecorder struct {
	mock *MockNodeStorage
}

// NewMockNodeStorage creates a new mock instance.
func NewMockNodeStorage(ctrl *gomock.Controller) *MockNodeStorage {
	mock := &MockNodeStorage{ctrl: ctrl}
	mock.recorder = &MockNodeStorageMockRecorder{mock}
	return mock
}

// EXPECT returns an object that allows the caller to indicate expected use.
func (m *MockNodeStorage) EXPECT() *MockNodeStorageMockRecorder {
	return m.recorder
}

// AllSpaceIds mocks base method.
func (m *MockNodeStorage) AllSpaceIds() ([]string, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AllSpaceIds")
	ret0, _ := ret[0].([]string)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// AllSpaceIds indicates an expected call of AllSpaceIds.
func (mr *MockNodeStorageMockRecorder) AllSpaceIds() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AllSpaceIds", reflect.TypeOf((*MockNodeStorage)(nil).AllSpaceIds))
}

// CreateSpaceStorage mocks base method.
func (m *MockNodeStorage) CreateSpaceStorage(ctx context.Context, payload spacestorage.SpaceStorageCreatePayload) (spacestorage.SpaceStorage, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateSpaceStorage", ctx, payload)
	ret0, _ := ret[0].(spacestorage.SpaceStorage)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CreateSpaceStorage indicates an expected call of CreateSpaceStorage.
func (mr *MockNodeStorageMockRecorder) CreateSpaceStorage(ctx, payload any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateSpaceStorage", reflect.TypeOf((*MockNodeStorage)(nil).CreateSpaceStorage), ctx, payload)
}

// DeleteSpaceStorage mocks base method.
func (m *MockNodeStorage) DeleteSpaceStorage(ctx context.Context, spaceId string) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteSpaceStorage", ctx, spaceId)
	ret0, _ := ret[0].(error)
	return ret0
}

// DeleteSpaceStorage indicates an expected call of DeleteSpaceStorage.
func (mr *MockNodeStorageMockRecorder) DeleteSpaceStorage(ctx, spaceId any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteSpaceStorage", reflect.TypeOf((*MockNodeStorage)(nil).DeleteSpaceStorage), ctx, spaceId)
}

// DumpStorage mocks base method.
func (m *MockNodeStorage) DumpStorage(ctx context.Context, id string, do func(string) error) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DumpStorage", ctx, id, do)
	ret0, _ := ret[0].(error)
	return ret0
}

// DumpStorage indicates an expected call of DumpStorage.
func (mr *MockNodeStorageMockRecorder) DumpStorage(ctx, id, do any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DumpStorage", reflect.TypeOf((*MockNodeStorage)(nil).DumpStorage), ctx, id, do)
}

// ForceRemove mocks base method.
func (m *MockNodeStorage) ForceRemove(id string) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ForceRemove", id)
	ret0, _ := ret[0].(error)
	return ret0
}

// ForceRemove indicates an expected call of ForceRemove.
func (mr *MockNodeStorageMockRecorder) ForceRemove(id any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ForceRemove", reflect.TypeOf((*MockNodeStorage)(nil).ForceRemove), id)
}

// GetStats mocks base method.
func (m *MockNodeStorage) GetStats(ctx context.Context, id string, treeTop int) (nodestorage.SpaceStats, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetStats", ctx, id, treeTop)
	ret0, _ := ret[0].(nodestorage.SpaceStats)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetStats indicates an expected call of GetStats.
func (mr *MockNodeStorageMockRecorder) GetStats(ctx, id, treeTop any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetStats", reflect.TypeOf((*MockNodeStorage)(nil).GetStats), ctx, id, treeTop)
}

// IndexSpace mocks base method.
func (m *MockNodeStorage) IndexSpace(ctx context.Context, spaceId string, setHead bool) (spacestorage.SpaceStorage, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "IndexSpace", ctx, spaceId, setHead)
	ret0, _ := ret[0].(spacestorage.SpaceStorage)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// IndexSpace indicates an expected call of IndexSpace.
func (mr *MockNodeStorageMockRecorder) IndexSpace(ctx, spaceId, setHead any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IndexSpace", reflect.TypeOf((*MockNodeStorage)(nil).IndexSpace), ctx, spaceId, setHead)
}

// IndexStorage mocks base method.
func (m *MockNodeStorage) IndexStorage() nodestorage.IndexStorage {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "IndexStorage")
	ret0, _ := ret[0].(nodestorage.IndexStorage)
	return ret0
}

// IndexStorage indicates an expected call of IndexStorage.
func (mr *MockNodeStorageMockRecorder) IndexStorage() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IndexStorage", reflect.TypeOf((*MockNodeStorage)(nil).IndexStorage))
}

// Init mocks base method.
func (m *MockNodeStorage) Init(a *app.App) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Init", a)
	ret0, _ := ret[0].(error)
	return ret0
}

// Init indicates an expected call of Init.
func (mr *MockNodeStorageMockRecorder) Init(a any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Init", reflect.TypeOf((*MockNodeStorage)(nil).Init), a)
}

// Name mocks base method.
func (m *MockNodeStorage) Name() string {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Name")
	ret0, _ := ret[0].(string)
	return ret0
}

// Name indicates an expected call of Name.
func (mr *MockNodeStorageMockRecorder) Name() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Name", reflect.TypeOf((*MockNodeStorage)(nil).Name))
}

// OnDeleteStorage mocks base method.
func (m *MockNodeStorage) OnDeleteStorage(onDelete func(context.Context, string)) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "OnDeleteStorage", onDelete)
}

// OnDeleteStorage indicates an expected call of OnDeleteStorage.
func (mr *MockNodeStorageMockRecorder) OnDeleteStorage(onDelete any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "OnDeleteStorage", reflect.TypeOf((*MockNodeStorage)(nil).OnDeleteStorage), onDelete)
}

// OnWriteHash mocks base method.
func (m *MockNodeStorage) OnWriteHash(onWrite func(context.Context, string, string, string)) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "OnWriteHash", onWrite)
}

// OnWriteHash indicates an expected call of OnWriteHash.
func (mr *MockNodeStorageMockRecorder) OnWriteHash(onWrite any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "OnWriteHash", reflect.TypeOf((*MockNodeStorage)(nil).OnWriteHash), onWrite)
}

// SpaceExists mocks base method.
func (m *MockNodeStorage) SpaceExists(id string) bool {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SpaceExists", id)
	ret0, _ := ret[0].(bool)
	return ret0
}

// SpaceExists indicates an expected call of SpaceExists.
func (mr *MockNodeStorageMockRecorder) SpaceExists(id any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SpaceExists", reflect.TypeOf((*MockNodeStorage)(nil).SpaceExists), id)
}

// SpaceStorage mocks base method.
func (m *MockNodeStorage) SpaceStorage(ctx context.Context, spaceId string) (spacestorage.SpaceStorage, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SpaceStorage", ctx, spaceId)
	ret0, _ := ret[0].(spacestorage.SpaceStorage)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// SpaceStorage indicates an expected call of SpaceStorage.
func (mr *MockNodeStorageMockRecorder) SpaceStorage(ctx, spaceId any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SpaceStorage", reflect.TypeOf((*MockNodeStorage)(nil).SpaceStorage), ctx, spaceId)
}

// StoreDir mocks base method.
func (m *MockNodeStorage) StoreDir(spaceId string) string {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "StoreDir", spaceId)
	ret0, _ := ret[0].(string)
	return ret0
}

// StoreDir indicates an expected call of StoreDir.
func (mr *MockNodeStorageMockRecorder) StoreDir(spaceId any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StoreDir", reflect.TypeOf((*MockNodeStorage)(nil).StoreDir), spaceId)
}

// TryLockAndDo mocks base method.
func (m *MockNodeStorage) TryLockAndDo(ctx context.Context, spaceId string, do nodestorage.DoFunc) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "TryLockAndDo", ctx, spaceId, do)
	ret0, _ := ret[0].(error)
	return ret0
}

// TryLockAndDo indicates an expected call of TryLockAndDo.
func (mr *MockNodeStorageMockRecorder) TryLockAndDo(ctx, spaceId, do any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TryLockAndDo", reflect.TypeOf((*MockNodeStorage)(nil).TryLockAndDo), ctx, spaceId, do)
}

// TryLockAndOpenDb mocks base method.
func (m *MockNodeStorage) TryLockAndOpenDb(ctx context.Context, spaceId string, do nodestorage.DoAfterOpenFunc) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "TryLockAndOpenDb", ctx, spaceId, do)
	ret0, _ := ret[0].(error)
	return ret0
}

// TryLockAndOpenDb indicates an expected call of TryLockAndOpenDb.
func (mr *MockNodeStorageMockRecorder) TryLockAndOpenDb(ctx, spaceId, do any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TryLockAndOpenDb", reflect.TypeOf((*MockNodeStorage)(nil).TryLockAndOpenDb), ctx, spaceId, do)
}

// WaitSpaceStorage mocks base method.
func (m *MockNodeStorage) WaitSpaceStorage(ctx context.Context, id string) (spacestorage.SpaceStorage, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "WaitSpaceStorage", ctx, id)
	ret0, _ := ret[0].(spacestorage.SpaceStorage)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// WaitSpaceStorage indicates an expected call of WaitSpaceStorage.
func (mr *MockNodeStorageMockRecorder) WaitSpaceStorage(ctx, id any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitSpaceStorage", reflect.TypeOf((*MockNodeStorage)(nil).WaitSpaceStorage), ctx, id)
}

// MockIndexStorage is a mock of IndexStorage interface.
type MockIndexStorage struct {
	ctrl     *gomock.Controller
	recorder *MockIndexStorageMockRecorder
	isgomock struct{}
}

// MockIndexStorageMockRecorder is the mock recorder for MockIndexStorage.
type MockIndexStorageMockRecorder struct {
	mock *MockIndexStorage
}

// NewMockIndexStorage creates a new mock instance.
func NewMockIndexStorage(ctrl *gomock.Controller) *MockIndexStorage {
	mock := &MockIndexStorage{ctrl: ctrl}
	mock.recorder = &MockIndexStorageMockRecorder{mock}
	return mock
}

// EXPECT returns an object that allows the caller to indicate expected use.
func (m *MockIndexStorage) EXPECT() *MockIndexStorageMockRecorder {
	return m.recorder
}

// Close mocks base method.
func (m *MockIndexStorage) Close() error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Close")
	ret0, _ := ret[0].(error)
	return ret0
}

// Close indicates an expected call of Close.
func (mr *MockIndexStorageMockRecorder) Close() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Close", reflect.TypeOf((*MockIndexStorage)(nil).Close))
}

// FindOldestInactiveSpace mocks base method.
func (m *MockIndexStorage) FindOldestInactiveSpace(ctx context.Context, olderThan time.Duration, skip int) (string, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "FindOldestInactiveSpace", ctx, olderThan, skip)
	ret0, _ := ret[0].(string)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// FindOldestInactiveSpace indicates an expected call of FindOldestInactiveSpace.
func (mr *MockIndexStorageMockRecorder) FindOldestInactiveSpace(ctx, olderThan, skip any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FindOldestInactiveSpace", reflect.TypeOf((*MockIndexStorage)(nil).FindOldestInactiveSpace), ctx, olderThan, skip)
}

// GetDiffMigrationVersion mocks base method.
func (m *MockIndexStorage) GetDiffMigrationVersion(ctx context.Context) (int, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetDiffMigrationVersion", ctx)
	ret0, _ := ret[0].(int)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetDiffMigrationVersion indicates an expected call of GetDiffMigrationVersion.
func (mr *MockIndexStorageMockRecorder) GetDiffMigrationVersion(ctx any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetDiffMigrationVersion", reflect.TypeOf((*MockIndexStorage)(nil).GetDiffMigrationVersion), ctx)
}

// LastRecordId mocks base method.
func (m *MockIndexStorage) LastRecordId(ctx context.Context) (string, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "LastRecordId", ctx)
	ret0, _ := ret[0].(string)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// LastRecordId indicates an expected call of LastRecordId.
func (mr *MockIndexStorageMockRecorder) LastRecordId(ctx any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LastRecordId", reflect.TypeOf((*MockIndexStorage)(nil).LastRecordId), ctx)
}

// MarkArchived mocks base method.
func (m *MockIndexStorage) MarkArchived(ctx context.Context, spaceId string, compressedSize, uncompressedSize int64) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "MarkArchived", ctx, spaceId, compressedSize, uncompressedSize)
	ret0, _ := ret[0].(error)
	return ret0
}

// MarkArchived indicates an expected call of MarkArchived.
func (mr *MockIndexStorageMockRecorder) MarkArchived(ctx, spaceId, compressedSize, uncompressedSize any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "MarkArchived", reflect.TypeOf((*MockIndexStorage)(nil).MarkArchived), ctx, spaceId, compressedSize, uncompressedSize)
}

// MarkError mocks base method.
func (m *MockIndexStorage) MarkError(ctx context.Context, spaceId, errString string) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "MarkError", ctx, spaceId, errString)
	ret0, _ := ret[0].(error)
	return ret0
}

// MarkError indicates an expected call of MarkError.
func (mr *MockIndexStorageMockRecorder) MarkError(ctx, spaceId, errString any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "MarkError", reflect.TypeOf((*MockIndexStorage)(nil).MarkError), ctx, spaceId, errString)
}

// ReadHashes mocks base method.
func (m *MockIndexStorage) ReadHashes(ctx context.Context, iterFunc func(nodestorage.SpaceUpdate) (bool, error)) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ReadHashes", ctx, iterFunc)
	ret0, _ := ret[0].(error)
	return ret0
}

// ReadHashes indicates an expected call of ReadHashes.
func (mr *MockIndexStorageMockRecorder) ReadHashes(ctx, iterFunc any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReadHashes", reflect.TypeOf((*MockIndexStorage)(nil).ReadHashes), ctx, iterFunc)
}

// RunMigrations mocks base method.
func (m *MockIndexStorage) RunMigrations(ctx context.Context) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "RunMigrations", ctx)
	ret0, _ := ret[0].(error)
	return ret0
}

// RunMigrations indicates an expected call of RunMigrations.
func (mr *MockIndexStorageMockRecorder) RunMigrations(ctx any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RunMigrations", reflect.TypeOf((*MockIndexStorage)(nil).RunMigrations), ctx)
}

// SetDiffMigrationVersion mocks base method.
func (m *MockIndexStorage) SetDiffMigrationVersion(ctx context.Context, version int) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SetDiffMigrationVersion", ctx, version)
	ret0, _ := ret[0].(error)
	return ret0
}

// SetDiffMigrationVersion indicates an expected call of SetDiffMigrationVersion.
func (mr *MockIndexStorageMockRecorder) SetDiffMigrationVersion(ctx, version any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetDiffMigrationVersion", reflect.TypeOf((*MockIndexStorage)(nil).SetDiffMigrationVersion), ctx, version)
}

// SetSpaceStatus mocks base method.
func (m *MockIndexStorage) SetSpaceStatus(ctx context.Context, spaceId string, status nodestorage.SpaceStatus, recId string) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SetSpaceStatus", ctx, spaceId, status, recId)
	ret0, _ := ret[0].(error)
	return ret0
}

// SetSpaceStatus indicates an expected call of SetSpaceStatus.
func (mr *MockIndexStorageMockRecorder) SetSpaceStatus(ctx, spaceId, status, recId any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetSpaceStatus", reflect.TypeOf((*MockIndexStorage)(nil).SetSpaceStatus), ctx, spaceId, status, recId)
}

// SpaceStatus mocks base method.
func (m *MockIndexStorage) SpaceStatus(ctx context.Context, spaceId string) (nodestorage.SpaceStatus, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SpaceStatus", ctx, spaceId)
	ret0, _ := ret[0].(nodestorage.SpaceStatus)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// SpaceStatus indicates an expected call of SpaceStatus.
func (mr *MockIndexStorageMockRecorder) SpaceStatus(ctx, spaceId any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SpaceStatus", reflect.TypeOf((*MockIndexStorage)(nil).SpaceStatus), ctx, spaceId)
}

// UpdateHash mocks base method.
func (m *MockIndexStorage) UpdateHash(ctx context.Context, updates ...nodestorage.SpaceUpdate) error {
	m.ctrl.T.Helper()
	varargs := []any{ctx}
	for _, a := range updates {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "UpdateHash", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

// UpdateHash indicates an expected call of UpdateHash.
func (mr *MockIndexStorageMockRecorder) UpdateHash(ctx any, updates ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx}, updates...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateHash", reflect.TypeOf((*MockIndexStorage)(nil).UpdateHash), varargs...)
}

// UpdateHashes mocks base method.
func (m *MockIndexStorage) UpdateHashes(ctx context.Context, updateFunc func(string, string, string) (string, string, bool)) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateHashes", ctx, updateFunc)
	ret0, _ := ret[0].(error)
	return ret0
}

// UpdateHashes indicates an expected call of UpdateHashes.
func (mr *MockIndexStorageMockRecorder) UpdateHashes(ctx, updateFunc any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateHashes", reflect.TypeOf((*MockIndexStorage)(nil).UpdateHashes), ctx, updateFunc)
}

// UpdateLastAccess mocks base method.
func (m *MockIndexStorage) UpdateLastAccess(ctx context.Context, spaceId string) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateLastAccess", ctx, spaceId)
	ret0, _ := ret[0].(error)
	return ret0
}

// UpdateLastAccess indicates an expected call of UpdateLastAccess.
func (mr *MockIndexStorageMockRecorder) UpdateLastAccess(ctx, spaceId any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateLastAccess", reflect.TypeOf((*MockIndexStorage)(nil).UpdateLastAccess), ctx, spaceId)
}
