// Code generated by mockery. DO NOT EDIT.

package mock_fileobject

import (
	context "context"

	app "github.com/anyproto/any-sync/app"

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

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

	filemodels "github.com/anyproto/anytype-heart/core/files/fileobject/filemodels"

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

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

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

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

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

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

// MockService is an autogenerated mock type for the Service type
type MockService struct {
	mock.Mock
}

type MockService_Expecter struct {
	mock *mock.Mock
}

func (_m *MockService) EXPECT() *MockService_Expecter {
	return &MockService_Expecter{mock: &_m.Mock}
}

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

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

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

	return r0
}

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

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

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

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

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

// Create provides a mock function with given fields: ctx, spaceId, req
func (_m *MockService) Create(ctx context.Context, spaceId string, req filemodels.CreateRequest) (string, *domain.Details, error) {
	ret := _m.Called(ctx, spaceId, req)

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

	var r0 string
	var r1 *domain.Details
	var r2 error
	if rf, ok := ret.Get(0).(func(context.Context, string, filemodels.CreateRequest) (string, *domain.Details, error)); ok {
		return rf(ctx, spaceId, req)
	}
	if rf, ok := ret.Get(0).(func(context.Context, string, filemodels.CreateRequest) string); ok {
		r0 = rf(ctx, spaceId, req)
	} else {
		r0 = ret.Get(0).(string)
	}

	if rf, ok := ret.Get(1).(func(context.Context, string, filemodels.CreateRequest) *domain.Details); ok {
		r1 = rf(ctx, spaceId, req)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*domain.Details)
		}
	}

	if rf, ok := ret.Get(2).(func(context.Context, string, filemodels.CreateRequest) error); ok {
		r2 = rf(ctx, spaceId, req)
	} else {
		r2 = ret.Error(2)
	}

	return r0, r1, r2
}

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

// Create is a helper method to define mock.On call
//   - ctx context.Context
//   - spaceId string
//   - req filemodels.CreateRequest
func (_e *MockService_Expecter) Create(ctx interface{}, spaceId interface{}, req interface{}) *MockService_Create_Call {
	return &MockService_Create_Call{Call: _e.mock.On("Create", ctx, spaceId, req)}
}

func (_c *MockService_Create_Call) Run(run func(ctx context.Context, spaceId string, req filemodels.CreateRequest)) *MockService_Create_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string), args[2].(filemodels.CreateRequest))
	})
	return _c
}

func (_c *MockService_Create_Call) Return(id string, object *domain.Details, err error) *MockService_Create_Call {
	_c.Call.Return(id, object, err)
	return _c
}

func (_c *MockService_Create_Call) RunAndReturn(run func(context.Context, string, filemodels.CreateRequest) (string, *domain.Details, error)) *MockService_Create_Call {
	_c.Call.Return(run)
	return _c
}

// CreateFromImport provides a mock function with given fields: fileId, origin
func (_m *MockService) CreateFromImport(fileId domain.FullFileId, origin objectorigin.ObjectOrigin) (string, error) {
	ret := _m.Called(fileId, origin)

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

	var r0 string
	var r1 error
	if rf, ok := ret.Get(0).(func(domain.FullFileId, objectorigin.ObjectOrigin) (string, error)); ok {
		return rf(fileId, origin)
	}
	if rf, ok := ret.Get(0).(func(domain.FullFileId, objectorigin.ObjectOrigin) string); ok {
		r0 = rf(fileId, origin)
	} else {
		r0 = ret.Get(0).(string)
	}

	if rf, ok := ret.Get(1).(func(domain.FullFileId, objectorigin.ObjectOrigin) error); ok {
		r1 = rf(fileId, origin)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// CreateFromImport is a helper method to define mock.On call
//   - fileId domain.FullFileId
//   - origin objectorigin.ObjectOrigin
func (_e *MockService_Expecter) CreateFromImport(fileId interface{}, origin interface{}) *MockService_CreateFromImport_Call {
	return &MockService_CreateFromImport_Call{Call: _e.mock.On("CreateFromImport", fileId, origin)}
}

func (_c *MockService_CreateFromImport_Call) Run(run func(fileId domain.FullFileId, origin objectorigin.ObjectOrigin)) *MockService_CreateFromImport_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(domain.FullFileId), args[1].(objectorigin.ObjectOrigin))
	})
	return _c
}

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

func (_c *MockService_CreateFromImport_Call) RunAndReturn(run func(domain.FullFileId, objectorigin.ObjectOrigin) (string, error)) *MockService_CreateFromImport_Call {
	_c.Call.Return(run)
	return _c
}

// DeleteFileData provides a mock function with given fields: spaceId, objectId
func (_m *MockService) DeleteFileData(spaceId string, objectId string) error {
	ret := _m.Called(spaceId, objectId)

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

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

	return r0
}

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

// DeleteFileData is a helper method to define mock.On call
//   - spaceId string
//   - objectId string
func (_e *MockService_Expecter) DeleteFileData(spaceId interface{}, objectId interface{}) *MockService_DeleteFileData_Call {
	return &MockService_DeleteFileData_Call{Call: _e.mock.On("DeleteFileData", spaceId, objectId)}
}

func (_c *MockService_DeleteFileData_Call) Run(run func(spaceId string, objectId string)) *MockService_DeleteFileData_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(string), args[1].(string))
	})
	return _c
}

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

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

// DoFileWaitLoad provides a mock function with given fields: ctx, objectId, proc
func (_m *MockService) DoFileWaitLoad(ctx context.Context, objectId string, proc func(editorfileobject.FileObject) error) error {
	ret := _m.Called(ctx, objectId, proc)

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

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

	return r0
}

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

// DoFileWaitLoad is a helper method to define mock.On call
//   - ctx context.Context
//   - objectId string
//   - proc func(editorfileobject.FileObject) error
func (_e *MockService_Expecter) DoFileWaitLoad(ctx interface{}, objectId interface{}, proc interface{}) *MockService_DoFileWaitLoad_Call {
	return &MockService_DoFileWaitLoad_Call{Call: _e.mock.On("DoFileWaitLoad", ctx, objectId, proc)}
}

func (_c *MockService_DoFileWaitLoad_Call) Run(run func(ctx context.Context, objectId string, proc func(editorfileobject.FileObject) error)) *MockService_DoFileWaitLoad_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string), args[2].(func(editorfileobject.FileObject) error))
	})
	return _c
}

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

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

// EnsureFileAddedToSyncQueue provides a mock function with given fields: id, details
func (_m *MockService) EnsureFileAddedToSyncQueue(id domain.FullID, details *domain.Details) error {
	ret := _m.Called(id, details)

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

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

	return r0
}

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

// EnsureFileAddedToSyncQueue is a helper method to define mock.On call
//   - id domain.FullID
//   - details *domain.Details
func (_e *MockService_Expecter) EnsureFileAddedToSyncQueue(id interface{}, details interface{}) *MockService_EnsureFileAddedToSyncQueue_Call {
	return &MockService_EnsureFileAddedToSyncQueue_Call{Call: _e.mock.On("EnsureFileAddedToSyncQueue", id, details)}
}

func (_c *MockService_EnsureFileAddedToSyncQueue_Call) Run(run func(id domain.FullID, details *domain.Details)) *MockService_EnsureFileAddedToSyncQueue_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(domain.FullID), args[1].(*domain.Details))
	})
	return _c
}

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

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

// GetFileData provides a mock function with given fields: ctx, objectId
func (_m *MockService) GetFileData(ctx context.Context, objectId string) (files.File, error) {
	ret := _m.Called(ctx, objectId)

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

	var r0 files.File
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, string) (files.File, error)); ok {
		return rf(ctx, objectId)
	}
	if rf, ok := ret.Get(0).(func(context.Context, string) files.File); ok {
		r0 = rf(ctx, objectId)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(files.File)
		}
	}

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

	return r0, r1
}

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

// GetFileData is a helper method to define mock.On call
//   - ctx context.Context
//   - objectId string
func (_e *MockService_Expecter) GetFileData(ctx interface{}, objectId interface{}) *MockService_GetFileData_Call {
	return &MockService_GetFileData_Call{Call: _e.mock.On("GetFileData", ctx, objectId)}
}

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

func (_c *MockService_GetFileData_Call) Return(_a0 files.File, _a1 error) *MockService_GetFileData_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

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

// GetFileIdFromObject provides a mock function with given fields: objectId
func (_m *MockService) GetFileIdFromObject(objectId string) (domain.FullFileId, error) {
	ret := _m.Called(objectId)

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

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

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

	return r0, r1
}

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

// GetFileIdFromObject is a helper method to define mock.On call
//   - objectId string
func (_e *MockService_Expecter) GetFileIdFromObject(objectId interface{}) *MockService_GetFileIdFromObject_Call {
	return &MockService_GetFileIdFromObject_Call{Call: _e.mock.On("GetFileIdFromObject", objectId)}
}

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

func (_c *MockService_GetFileIdFromObject_Call) Return(_a0 domain.FullFileId, _a1 error) *MockService_GetFileIdFromObject_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

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

// GetImageData provides a mock function with given fields: ctx, objectId
func (_m *MockService) GetImageData(ctx context.Context, objectId string) (files.Image, error) {
	ret := _m.Called(ctx, objectId)

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

	var r0 files.Image
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, string) (files.Image, error)); ok {
		return rf(ctx, objectId)
	}
	if rf, ok := ret.Get(0).(func(context.Context, string) files.Image); ok {
		r0 = rf(ctx, objectId)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(files.Image)
		}
	}

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

	return r0, r1
}

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

// GetImageData is a helper method to define mock.On call
//   - ctx context.Context
//   - objectId string
func (_e *MockService_Expecter) GetImageData(ctx interface{}, objectId interface{}) *MockService_GetImageData_Call {
	return &MockService_GetImageData_Call{Call: _e.mock.On("GetImageData", ctx, objectId)}
}

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

func (_c *MockService_GetImageData_Call) Return(_a0 files.Image, _a1 error) *MockService_GetImageData_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

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

// GetImageDataFromRawId provides a mock function with given fields: ctx, fileId
func (_m *MockService) GetImageDataFromRawId(ctx context.Context, fileId domain.FileId) (files.Image, error) {
	ret := _m.Called(ctx, fileId)

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

	var r0 files.Image
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, domain.FileId) (files.Image, error)); ok {
		return rf(ctx, fileId)
	}
	if rf, ok := ret.Get(0).(func(context.Context, domain.FileId) files.Image); ok {
		r0 = rf(ctx, fileId)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(files.Image)
		}
	}

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

	return r0, r1
}

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

// GetImageDataFromRawId is a helper method to define mock.On call
//   - ctx context.Context
//   - fileId domain.FileId
func (_e *MockService_Expecter) GetImageDataFromRawId(ctx interface{}, fileId interface{}) *MockService_GetImageDataFromRawId_Call {
	return &MockService_GetImageDataFromRawId_Call{Call: _e.mock.On("GetImageDataFromRawId", ctx, fileId)}
}

func (_c *MockService_GetImageDataFromRawId_Call) Run(run func(ctx context.Context, fileId domain.FileId)) *MockService_GetImageDataFromRawId_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(domain.FileId))
	})
	return _c
}

func (_c *MockService_GetImageDataFromRawId_Call) Return(_a0 files.Image, _a1 error) *MockService_GetImageDataFromRawId_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockService_GetImageDataFromRawId_Call) RunAndReturn(run func(context.Context, domain.FileId) (files.Image, error)) *MockService_GetImageDataFromRawId_Call {
	_c.Call.Return(run)
	return _c
}

// GetObjectDetailsByFileId provides a mock function with given fields: fileId
func (_m *MockService) GetObjectDetailsByFileId(fileId domain.FullFileId) (string, *domain.Details, error) {
	ret := _m.Called(fileId)

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

	var r0 string
	var r1 *domain.Details
	var r2 error
	if rf, ok := ret.Get(0).(func(domain.FullFileId) (string, *domain.Details, error)); ok {
		return rf(fileId)
	}
	if rf, ok := ret.Get(0).(func(domain.FullFileId) string); ok {
		r0 = rf(fileId)
	} else {
		r0 = ret.Get(0).(string)
	}

	if rf, ok := ret.Get(1).(func(domain.FullFileId) *domain.Details); ok {
		r1 = rf(fileId)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*domain.Details)
		}
	}

	if rf, ok := ret.Get(2).(func(domain.FullFileId) error); ok {
		r2 = rf(fileId)
	} else {
		r2 = ret.Error(2)
	}

	return r0, r1, r2
}

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

// GetObjectDetailsByFileId is a helper method to define mock.On call
//   - fileId domain.FullFileId
func (_e *MockService_Expecter) GetObjectDetailsByFileId(fileId interface{}) *MockService_GetObjectDetailsByFileId_Call {
	return &MockService_GetObjectDetailsByFileId_Call{Call: _e.mock.On("GetObjectDetailsByFileId", fileId)}
}

func (_c *MockService_GetObjectDetailsByFileId_Call) Run(run func(fileId domain.FullFileId)) *MockService_GetObjectDetailsByFileId_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(domain.FullFileId))
	})
	return _c
}

func (_c *MockService_GetObjectDetailsByFileId_Call) Return(_a0 string, _a1 *domain.Details, _a2 error) *MockService_GetObjectDetailsByFileId_Call {
	_c.Call.Return(_a0, _a1, _a2)
	return _c
}

func (_c *MockService_GetObjectDetailsByFileId_Call) RunAndReturn(run func(domain.FullFileId) (string, *domain.Details, error)) *MockService_GetObjectDetailsByFileId_Call {
	_c.Call.Return(run)
	return _c
}

// Init provides a mock function with given fields: a
func (_m *MockService) Init(a *app.App) error {
	ret := _m.Called(a)

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

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

	return r0
}

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

// Init is a helper method to define mock.On call
//   - a *app.App
func (_e *MockService_Expecter) Init(a interface{}) *MockService_Init_Call {
	return &MockService_Init_Call{Call: _e.mock.On("Init", a)}
}

func (_c *MockService_Init_Call) Run(run func(a *app.App)) *MockService_Init_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(*app.App))
	})
	return _c
}

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

func (_c *MockService_Init_Call) RunAndReturn(run func(*app.App) error) *MockService_Init_Call {
	_c.Call.Return(run)
	return _c
}

// InitEmptyFileState provides a mock function with given fields: st
func (_m *MockService) InitEmptyFileState(st *state.State) {
	_m.Called(st)
}

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

// InitEmptyFileState is a helper method to define mock.On call
//   - st *state.State
func (_e *MockService_Expecter) InitEmptyFileState(st interface{}) *MockService_InitEmptyFileState_Call {
	return &MockService_InitEmptyFileState_Call{Call: _e.mock.On("InitEmptyFileState", st)}
}

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

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

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

// MigrateFileIdsInBlocks provides a mock function with given fields: st, spc
func (_m *MockService) MigrateFileIdsInBlocks(st *state.State, spc source.Space) {
	_m.Called(st, spc)
}

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

// MigrateFileIdsInBlocks is a helper method to define mock.On call
//   - st *state.State
//   - spc source.Space
func (_e *MockService_Expecter) MigrateFileIdsInBlocks(st interface{}, spc interface{}) *MockService_MigrateFileIdsInBlocks_Call {
	return &MockService_MigrateFileIdsInBlocks_Call{Call: _e.mock.On("MigrateFileIdsInBlocks", st, spc)}
}

func (_c *MockService_MigrateFileIdsInBlocks_Call) Run(run func(st *state.State, spc source.Space)) *MockService_MigrateFileIdsInBlocks_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(*state.State), args[1].(source.Space))
	})
	return _c
}

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

func (_c *MockService_MigrateFileIdsInBlocks_Call) RunAndReturn(run func(*state.State, source.Space)) *MockService_MigrateFileIdsInBlocks_Call {
	_c.Call.Return(run)
	return _c
}

// MigrateFileIdsInDetails provides a mock function with given fields: st, spc
func (_m *MockService) MigrateFileIdsInDetails(st *state.State, spc source.Space) {
	_m.Called(st, spc)
}

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

// MigrateFileIdsInDetails is a helper method to define mock.On call
//   - st *state.State
//   - spc source.Space
func (_e *MockService_Expecter) MigrateFileIdsInDetails(st interface{}, spc interface{}) *MockService_MigrateFileIdsInDetails_Call {
	return &MockService_MigrateFileIdsInDetails_Call{Call: _e.mock.On("MigrateFileIdsInDetails", st, spc)}
}

func (_c *MockService_MigrateFileIdsInDetails_Call) Run(run func(st *state.State, spc source.Space)) *MockService_MigrateFileIdsInDetails_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(*state.State), args[1].(source.Space))
	})
	return _c
}

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

func (_c *MockService_MigrateFileIdsInDetails_Call) RunAndReturn(run func(*state.State, source.Space)) *MockService_MigrateFileIdsInDetails_Call {
	_c.Call.Return(run)
	return _c
}

// MigrateFiles provides a mock function with given fields: st, spc, keysChanges
func (_m *MockService) MigrateFiles(st *state.State, spc source.Space, keysChanges []*pb.ChangeFileKeys) {
	_m.Called(st, spc, keysChanges)
}

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

// MigrateFiles is a helper method to define mock.On call
//   - st *state.State
//   - spc source.Space
//   - keysChanges []*pb.ChangeFileKeys
func (_e *MockService_Expecter) MigrateFiles(st interface{}, spc interface{}, keysChanges interface{}) *MockService_MigrateFiles_Call {
	return &MockService_MigrateFiles_Call{Call: _e.mock.On("MigrateFiles", st, spc, keysChanges)}
}

func (_c *MockService_MigrateFiles_Call) Run(run func(st *state.State, spc source.Space, keysChanges []*pb.ChangeFileKeys)) *MockService_MigrateFiles_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(*state.State), args[1].(source.Space), args[2].([]*pb.ChangeFileKeys))
	})
	return _c
}

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

func (_c *MockService_MigrateFiles_Call) RunAndReturn(run func(*state.State, source.Space, []*pb.ChangeFileKeys)) *MockService_MigrateFiles_Call {
	_c.Call.Return(run)
	return _c
}

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

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

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

	return r0
}

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

// Name is a helper method to define mock.On call
func (_e *MockService_Expecter) Name() *MockService_Name_Call {
	return &MockService_Name_Call{Call: _e.mock.On("Name")}
}

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

func (_c *MockService_Name_Call) Return(name string) *MockService_Name_Call {
	_c.Call.Return(name)
	return _c
}

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

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

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

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

	return r0
}

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

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

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

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

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

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

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

	return mock
}
