// Code generated by mockery; DO NOT EDIT.
// github.com/vektra/mockery
// template: testify

package mocks

import (
	"context"
	"time"

	"github.com/kopia/kopia/repo"
	"github.com/kopia/kopia/repo/content"
	"github.com/kopia/kopia/repo/manifest"
	"github.com/kopia/kopia/repo/object"
	mock "github.com/stretchr/testify/mock"
)

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

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

	return mock
}

// MockRepositoryWriter is an autogenerated mock type for the RepositoryWriter type
type MockRepositoryWriter struct {
	mock.Mock
}

type MockRepositoryWriter_Expecter struct {
	mock *mock.Mock
}

func (_m *MockRepositoryWriter) EXPECT() *MockRepositoryWriter_Expecter {
	return &MockRepositoryWriter_Expecter{mock: &_m.Mock}
}

// ClientOptions provides a mock function for the type MockRepositoryWriter
func (_mock *MockRepositoryWriter) ClientOptions() repo.ClientOptions {
	ret := _mock.Called()

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

	var r0 repo.ClientOptions
	if returnFunc, ok := ret.Get(0).(func() repo.ClientOptions); ok {
		r0 = returnFunc()
	} else {
		r0 = ret.Get(0).(repo.ClientOptions)
	}
	return r0
}

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

// ClientOptions is a helper method to define mock.On call
func (_e *MockRepositoryWriter_Expecter) ClientOptions() *MockRepositoryWriter_ClientOptions_Call {
	return &MockRepositoryWriter_ClientOptions_Call{Call: _e.mock.On("ClientOptions")}
}

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

func (_c *MockRepositoryWriter_ClientOptions_Call) Return(clientOptions repo.ClientOptions) *MockRepositoryWriter_ClientOptions_Call {
	_c.Call.Return(clientOptions)
	return _c
}

func (_c *MockRepositoryWriter_ClientOptions_Call) RunAndReturn(run func() repo.ClientOptions) *MockRepositoryWriter_ClientOptions_Call {
	_c.Call.Return(run)
	return _c
}

// Close provides a mock function for the type MockRepositoryWriter
func (_mock *MockRepositoryWriter) Close(ctx context.Context) error {
	ret := _mock.Called(ctx)

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

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

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

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

func (_c *MockRepositoryWriter_Close_Call) Run(run func(ctx context.Context)) *MockRepositoryWriter_Close_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		run(
			arg0,
		)
	})
	return _c
}

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

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

// ConcatenateObjects provides a mock function for the type MockRepositoryWriter
func (_mock *MockRepositoryWriter) ConcatenateObjects(ctx context.Context, objectIDs []object.ID, opt repo.ConcatenateOptions) (object.ID, error) {
	ret := _mock.Called(ctx, objectIDs, opt)

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

	var r0 object.ID
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, []object.ID, repo.ConcatenateOptions) (object.ID, error)); ok {
		return returnFunc(ctx, objectIDs, opt)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, []object.ID, repo.ConcatenateOptions) object.ID); ok {
		r0 = returnFunc(ctx, objectIDs, opt)
	} else {
		r0 = ret.Get(0).(object.ID)
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, []object.ID, repo.ConcatenateOptions) error); ok {
		r1 = returnFunc(ctx, objectIDs, opt)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// ConcatenateObjects is a helper method to define mock.On call
//   - ctx context.Context
//   - objectIDs []object.ID
//   - opt repo.ConcatenateOptions
func (_e *MockRepositoryWriter_Expecter) ConcatenateObjects(ctx interface{}, objectIDs interface{}, opt interface{}) *MockRepositoryWriter_ConcatenateObjects_Call {
	return &MockRepositoryWriter_ConcatenateObjects_Call{Call: _e.mock.On("ConcatenateObjects", ctx, objectIDs, opt)}
}

func (_c *MockRepositoryWriter_ConcatenateObjects_Call) Run(run func(ctx context.Context, objectIDs []object.ID, opt repo.ConcatenateOptions)) *MockRepositoryWriter_ConcatenateObjects_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 []object.ID
		if args[1] != nil {
			arg1 = args[1].([]object.ID)
		}
		var arg2 repo.ConcatenateOptions
		if args[2] != nil {
			arg2 = args[2].(repo.ConcatenateOptions)
		}
		run(
			arg0,
			arg1,
			arg2,
		)
	})
	return _c
}

func (_c *MockRepositoryWriter_ConcatenateObjects_Call) Return(iD object.ID, err error) *MockRepositoryWriter_ConcatenateObjects_Call {
	_c.Call.Return(iD, err)
	return _c
}

func (_c *MockRepositoryWriter_ConcatenateObjects_Call) RunAndReturn(run func(ctx context.Context, objectIDs []object.ID, opt repo.ConcatenateOptions) (object.ID, error)) *MockRepositoryWriter_ConcatenateObjects_Call {
	_c.Call.Return(run)
	return _c
}

// ContentInfo provides a mock function for the type MockRepositoryWriter
func (_mock *MockRepositoryWriter) ContentInfo(ctx context.Context, contentID content.ID) (content.Info, error) {
	ret := _mock.Called(ctx, contentID)

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

	var r0 content.Info
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, content.ID) (content.Info, error)); ok {
		return returnFunc(ctx, contentID)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, content.ID) content.Info); ok {
		r0 = returnFunc(ctx, contentID)
	} else {
		r0 = ret.Get(0).(content.Info)
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, content.ID) error); ok {
		r1 = returnFunc(ctx, contentID)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// ContentInfo is a helper method to define mock.On call
//   - ctx context.Context
//   - contentID content.ID
func (_e *MockRepositoryWriter_Expecter) ContentInfo(ctx interface{}, contentID interface{}) *MockRepositoryWriter_ContentInfo_Call {
	return &MockRepositoryWriter_ContentInfo_Call{Call: _e.mock.On("ContentInfo", ctx, contentID)}
}

func (_c *MockRepositoryWriter_ContentInfo_Call) Run(run func(ctx context.Context, contentID content.ID)) *MockRepositoryWriter_ContentInfo_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 content.ID
		if args[1] != nil {
			arg1 = args[1].(content.ID)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *MockRepositoryWriter_ContentInfo_Call) Return(v content.Info, err error) *MockRepositoryWriter_ContentInfo_Call {
	_c.Call.Return(v, err)
	return _c
}

func (_c *MockRepositoryWriter_ContentInfo_Call) RunAndReturn(run func(ctx context.Context, contentID content.ID) (content.Info, error)) *MockRepositoryWriter_ContentInfo_Call {
	_c.Call.Return(run)
	return _c
}

// DeleteManifest provides a mock function for the type MockRepositoryWriter
func (_mock *MockRepositoryWriter) DeleteManifest(ctx context.Context, id manifest.ID) error {
	ret := _mock.Called(ctx, id)

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

	var r0 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, manifest.ID) error); ok {
		r0 = returnFunc(ctx, id)
	} else {
		r0 = ret.Error(0)
	}
	return r0
}

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

// DeleteManifest is a helper method to define mock.On call
//   - ctx context.Context
//   - id manifest.ID
func (_e *MockRepositoryWriter_Expecter) DeleteManifest(ctx interface{}, id interface{}) *MockRepositoryWriter_DeleteManifest_Call {
	return &MockRepositoryWriter_DeleteManifest_Call{Call: _e.mock.On("DeleteManifest", ctx, id)}
}

func (_c *MockRepositoryWriter_DeleteManifest_Call) Run(run func(ctx context.Context, id manifest.ID)) *MockRepositoryWriter_DeleteManifest_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 manifest.ID
		if args[1] != nil {
			arg1 = args[1].(manifest.ID)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

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

func (_c *MockRepositoryWriter_DeleteManifest_Call) RunAndReturn(run func(ctx context.Context, id manifest.ID) error) *MockRepositoryWriter_DeleteManifest_Call {
	_c.Call.Return(run)
	return _c
}

// FindManifests provides a mock function for the type MockRepositoryWriter
func (_mock *MockRepositoryWriter) FindManifests(ctx context.Context, labels map[string]string) ([]*manifest.EntryMetadata, error) {
	ret := _mock.Called(ctx, labels)

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

	var r0 []*manifest.EntryMetadata
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, map[string]string) ([]*manifest.EntryMetadata, error)); ok {
		return returnFunc(ctx, labels)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, map[string]string) []*manifest.EntryMetadata); ok {
		r0 = returnFunc(ctx, labels)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]*manifest.EntryMetadata)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, map[string]string) error); ok {
		r1 = returnFunc(ctx, labels)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// FindManifests is a helper method to define mock.On call
//   - ctx context.Context
//   - labels map[string]string
func (_e *MockRepositoryWriter_Expecter) FindManifests(ctx interface{}, labels interface{}) *MockRepositoryWriter_FindManifests_Call {
	return &MockRepositoryWriter_FindManifests_Call{Call: _e.mock.On("FindManifests", ctx, labels)}
}

func (_c *MockRepositoryWriter_FindManifests_Call) Run(run func(ctx context.Context, labels map[string]string)) *MockRepositoryWriter_FindManifests_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 map[string]string
		if args[1] != nil {
			arg1 = args[1].(map[string]string)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *MockRepositoryWriter_FindManifests_Call) Return(entryMetadatas []*manifest.EntryMetadata, err error) *MockRepositoryWriter_FindManifests_Call {
	_c.Call.Return(entryMetadatas, err)
	return _c
}

func (_c *MockRepositoryWriter_FindManifests_Call) RunAndReturn(run func(ctx context.Context, labels map[string]string) ([]*manifest.EntryMetadata, error)) *MockRepositoryWriter_FindManifests_Call {
	_c.Call.Return(run)
	return _c
}

// Flush provides a mock function for the type MockRepositoryWriter
func (_mock *MockRepositoryWriter) Flush(ctx context.Context) error {
	ret := _mock.Called(ctx)

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

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

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

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

func (_c *MockRepositoryWriter_Flush_Call) Run(run func(ctx context.Context)) *MockRepositoryWriter_Flush_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		run(
			arg0,
		)
	})
	return _c
}

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

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

// GetManifest provides a mock function for the type MockRepositoryWriter
func (_mock *MockRepositoryWriter) GetManifest(ctx context.Context, id manifest.ID, data any) (*manifest.EntryMetadata, error) {
	ret := _mock.Called(ctx, id, data)

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

	var r0 *manifest.EntryMetadata
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, manifest.ID, any) (*manifest.EntryMetadata, error)); ok {
		return returnFunc(ctx, id, data)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, manifest.ID, any) *manifest.EntryMetadata); ok {
		r0 = returnFunc(ctx, id, data)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*manifest.EntryMetadata)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, manifest.ID, any) error); ok {
		r1 = returnFunc(ctx, id, data)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// GetManifest is a helper method to define mock.On call
//   - ctx context.Context
//   - id manifest.ID
//   - data any
func (_e *MockRepositoryWriter_Expecter) GetManifest(ctx interface{}, id interface{}, data interface{}) *MockRepositoryWriter_GetManifest_Call {
	return &MockRepositoryWriter_GetManifest_Call{Call: _e.mock.On("GetManifest", ctx, id, data)}
}

func (_c *MockRepositoryWriter_GetManifest_Call) Run(run func(ctx context.Context, id manifest.ID, data any)) *MockRepositoryWriter_GetManifest_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 manifest.ID
		if args[1] != nil {
			arg1 = args[1].(manifest.ID)
		}
		var arg2 any
		if args[2] != nil {
			arg2 = args[2].(any)
		}
		run(
			arg0,
			arg1,
			arg2,
		)
	})
	return _c
}

func (_c *MockRepositoryWriter_GetManifest_Call) Return(entryMetadata *manifest.EntryMetadata, err error) *MockRepositoryWriter_GetManifest_Call {
	_c.Call.Return(entryMetadata, err)
	return _c
}

func (_c *MockRepositoryWriter_GetManifest_Call) RunAndReturn(run func(ctx context.Context, id manifest.ID, data any) (*manifest.EntryMetadata, error)) *MockRepositoryWriter_GetManifest_Call {
	_c.Call.Return(run)
	return _c
}

// NewObjectWriter provides a mock function for the type MockRepositoryWriter
func (_mock *MockRepositoryWriter) NewObjectWriter(ctx context.Context, opt object.WriterOptions) object.Writer {
	ret := _mock.Called(ctx, opt)

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

	var r0 object.Writer
	if returnFunc, ok := ret.Get(0).(func(context.Context, object.WriterOptions) object.Writer); ok {
		r0 = returnFunc(ctx, opt)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(object.Writer)
		}
	}
	return r0
}

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

// NewObjectWriter is a helper method to define mock.On call
//   - ctx context.Context
//   - opt object.WriterOptions
func (_e *MockRepositoryWriter_Expecter) NewObjectWriter(ctx interface{}, opt interface{}) *MockRepositoryWriter_NewObjectWriter_Call {
	return &MockRepositoryWriter_NewObjectWriter_Call{Call: _e.mock.On("NewObjectWriter", ctx, opt)}
}

func (_c *MockRepositoryWriter_NewObjectWriter_Call) Run(run func(ctx context.Context, opt object.WriterOptions)) *MockRepositoryWriter_NewObjectWriter_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 object.WriterOptions
		if args[1] != nil {
			arg1 = args[1].(object.WriterOptions)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *MockRepositoryWriter_NewObjectWriter_Call) Return(writer object.Writer) *MockRepositoryWriter_NewObjectWriter_Call {
	_c.Call.Return(writer)
	return _c
}

func (_c *MockRepositoryWriter_NewObjectWriter_Call) RunAndReturn(run func(ctx context.Context, opt object.WriterOptions) object.Writer) *MockRepositoryWriter_NewObjectWriter_Call {
	_c.Call.Return(run)
	return _c
}

// NewWriter provides a mock function for the type MockRepositoryWriter
func (_mock *MockRepositoryWriter) NewWriter(ctx context.Context, opt repo.WriteSessionOptions) (context.Context, repo.RepositoryWriter, error) {
	ret := _mock.Called(ctx, opt)

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

	var r0 context.Context
	var r1 repo.RepositoryWriter
	var r2 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, repo.WriteSessionOptions) (context.Context, repo.RepositoryWriter, error)); ok {
		return returnFunc(ctx, opt)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, repo.WriteSessionOptions) context.Context); ok {
		r0 = returnFunc(ctx, opt)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(context.Context)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, repo.WriteSessionOptions) repo.RepositoryWriter); ok {
		r1 = returnFunc(ctx, opt)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(repo.RepositoryWriter)
		}
	}
	if returnFunc, ok := ret.Get(2).(func(context.Context, repo.WriteSessionOptions) error); ok {
		r2 = returnFunc(ctx, opt)
	} else {
		r2 = ret.Error(2)
	}
	return r0, r1, r2
}

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

// NewWriter is a helper method to define mock.On call
//   - ctx context.Context
//   - opt repo.WriteSessionOptions
func (_e *MockRepositoryWriter_Expecter) NewWriter(ctx interface{}, opt interface{}) *MockRepositoryWriter_NewWriter_Call {
	return &MockRepositoryWriter_NewWriter_Call{Call: _e.mock.On("NewWriter", ctx, opt)}
}

func (_c *MockRepositoryWriter_NewWriter_Call) Run(run func(ctx context.Context, opt repo.WriteSessionOptions)) *MockRepositoryWriter_NewWriter_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 repo.WriteSessionOptions
		if args[1] != nil {
			arg1 = args[1].(repo.WriteSessionOptions)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *MockRepositoryWriter_NewWriter_Call) Return(context1 context.Context, repositoryWriter repo.RepositoryWriter, err error) *MockRepositoryWriter_NewWriter_Call {
	_c.Call.Return(context1, repositoryWriter, err)
	return _c
}

func (_c *MockRepositoryWriter_NewWriter_Call) RunAndReturn(run func(ctx context.Context, opt repo.WriteSessionOptions) (context.Context, repo.RepositoryWriter, error)) *MockRepositoryWriter_NewWriter_Call {
	_c.Call.Return(run)
	return _c
}

// OnSuccessfulFlush provides a mock function for the type MockRepositoryWriter
func (_mock *MockRepositoryWriter) OnSuccessfulFlush(callback repo.RepositoryWriterCallback) {
	_mock.Called(callback)
	return
}

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

// OnSuccessfulFlush is a helper method to define mock.On call
//   - callback repo.RepositoryWriterCallback
func (_e *MockRepositoryWriter_Expecter) OnSuccessfulFlush(callback interface{}) *MockRepositoryWriter_OnSuccessfulFlush_Call {
	return &MockRepositoryWriter_OnSuccessfulFlush_Call{Call: _e.mock.On("OnSuccessfulFlush", callback)}
}

func (_c *MockRepositoryWriter_OnSuccessfulFlush_Call) Run(run func(callback repo.RepositoryWriterCallback)) *MockRepositoryWriter_OnSuccessfulFlush_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 repo.RepositoryWriterCallback
		if args[0] != nil {
			arg0 = args[0].(repo.RepositoryWriterCallback)
		}
		run(
			arg0,
		)
	})
	return _c
}

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

func (_c *MockRepositoryWriter_OnSuccessfulFlush_Call) RunAndReturn(run func(callback repo.RepositoryWriterCallback)) *MockRepositoryWriter_OnSuccessfulFlush_Call {
	_c.Run(run)
	return _c
}

// OpenObject provides a mock function for the type MockRepositoryWriter
func (_mock *MockRepositoryWriter) OpenObject(ctx context.Context, id object.ID) (object.Reader, error) {
	ret := _mock.Called(ctx, id)

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

	var r0 object.Reader
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, object.ID) (object.Reader, error)); ok {
		return returnFunc(ctx, id)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, object.ID) object.Reader); ok {
		r0 = returnFunc(ctx, id)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(object.Reader)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, object.ID) error); ok {
		r1 = returnFunc(ctx, id)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// OpenObject is a helper method to define mock.On call
//   - ctx context.Context
//   - id object.ID
func (_e *MockRepositoryWriter_Expecter) OpenObject(ctx interface{}, id interface{}) *MockRepositoryWriter_OpenObject_Call {
	return &MockRepositoryWriter_OpenObject_Call{Call: _e.mock.On("OpenObject", ctx, id)}
}

func (_c *MockRepositoryWriter_OpenObject_Call) Run(run func(ctx context.Context, id object.ID)) *MockRepositoryWriter_OpenObject_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 object.ID
		if args[1] != nil {
			arg1 = args[1].(object.ID)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *MockRepositoryWriter_OpenObject_Call) Return(reader object.Reader, err error) *MockRepositoryWriter_OpenObject_Call {
	_c.Call.Return(reader, err)
	return _c
}

func (_c *MockRepositoryWriter_OpenObject_Call) RunAndReturn(run func(ctx context.Context, id object.ID) (object.Reader, error)) *MockRepositoryWriter_OpenObject_Call {
	_c.Call.Return(run)
	return _c
}

// PrefetchContents provides a mock function for the type MockRepositoryWriter
func (_mock *MockRepositoryWriter) PrefetchContents(ctx context.Context, contentIDs []content.ID, hint string) []content.ID {
	ret := _mock.Called(ctx, contentIDs, hint)

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

	var r0 []content.ID
	if returnFunc, ok := ret.Get(0).(func(context.Context, []content.ID, string) []content.ID); ok {
		r0 = returnFunc(ctx, contentIDs, hint)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]content.ID)
		}
	}
	return r0
}

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

// PrefetchContents is a helper method to define mock.On call
//   - ctx context.Context
//   - contentIDs []content.ID
//   - hint string
func (_e *MockRepositoryWriter_Expecter) PrefetchContents(ctx interface{}, contentIDs interface{}, hint interface{}) *MockRepositoryWriter_PrefetchContents_Call {
	return &MockRepositoryWriter_PrefetchContents_Call{Call: _e.mock.On("PrefetchContents", ctx, contentIDs, hint)}
}

func (_c *MockRepositoryWriter_PrefetchContents_Call) Run(run func(ctx context.Context, contentIDs []content.ID, hint string)) *MockRepositoryWriter_PrefetchContents_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 []content.ID
		if args[1] != nil {
			arg1 = args[1].([]content.ID)
		}
		var arg2 string
		if args[2] != nil {
			arg2 = args[2].(string)
		}
		run(
			arg0,
			arg1,
			arg2,
		)
	})
	return _c
}

func (_c *MockRepositoryWriter_PrefetchContents_Call) Return(vs []content.ID) *MockRepositoryWriter_PrefetchContents_Call {
	_c.Call.Return(vs)
	return _c
}

func (_c *MockRepositoryWriter_PrefetchContents_Call) RunAndReturn(run func(ctx context.Context, contentIDs []content.ID, hint string) []content.ID) *MockRepositoryWriter_PrefetchContents_Call {
	_c.Call.Return(run)
	return _c
}

// PrefetchObjects provides a mock function for the type MockRepositoryWriter
func (_mock *MockRepositoryWriter) PrefetchObjects(ctx context.Context, objectIDs []object.ID, hint string) ([]content.ID, error) {
	ret := _mock.Called(ctx, objectIDs, hint)

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

	var r0 []content.ID
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, []object.ID, string) ([]content.ID, error)); ok {
		return returnFunc(ctx, objectIDs, hint)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, []object.ID, string) []content.ID); ok {
		r0 = returnFunc(ctx, objectIDs, hint)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]content.ID)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, []object.ID, string) error); ok {
		r1 = returnFunc(ctx, objectIDs, hint)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// PrefetchObjects is a helper method to define mock.On call
//   - ctx context.Context
//   - objectIDs []object.ID
//   - hint string
func (_e *MockRepositoryWriter_Expecter) PrefetchObjects(ctx interface{}, objectIDs interface{}, hint interface{}) *MockRepositoryWriter_PrefetchObjects_Call {
	return &MockRepositoryWriter_PrefetchObjects_Call{Call: _e.mock.On("PrefetchObjects", ctx, objectIDs, hint)}
}

func (_c *MockRepositoryWriter_PrefetchObjects_Call) Run(run func(ctx context.Context, objectIDs []object.ID, hint string)) *MockRepositoryWriter_PrefetchObjects_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 []object.ID
		if args[1] != nil {
			arg1 = args[1].([]object.ID)
		}
		var arg2 string
		if args[2] != nil {
			arg2 = args[2].(string)
		}
		run(
			arg0,
			arg1,
			arg2,
		)
	})
	return _c
}

func (_c *MockRepositoryWriter_PrefetchObjects_Call) Return(vs []content.ID, err error) *MockRepositoryWriter_PrefetchObjects_Call {
	_c.Call.Return(vs, err)
	return _c
}

func (_c *MockRepositoryWriter_PrefetchObjects_Call) RunAndReturn(run func(ctx context.Context, objectIDs []object.ID, hint string) ([]content.ID, error)) *MockRepositoryWriter_PrefetchObjects_Call {
	_c.Call.Return(run)
	return _c
}

// PutManifest provides a mock function for the type MockRepositoryWriter
func (_mock *MockRepositoryWriter) PutManifest(ctx context.Context, labels map[string]string, payload any) (manifest.ID, error) {
	ret := _mock.Called(ctx, labels, payload)

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

	var r0 manifest.ID
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, map[string]string, any) (manifest.ID, error)); ok {
		return returnFunc(ctx, labels, payload)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, map[string]string, any) manifest.ID); ok {
		r0 = returnFunc(ctx, labels, payload)
	} else {
		r0 = ret.Get(0).(manifest.ID)
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, map[string]string, any) error); ok {
		r1 = returnFunc(ctx, labels, payload)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// PutManifest is a helper method to define mock.On call
//   - ctx context.Context
//   - labels map[string]string
//   - payload any
func (_e *MockRepositoryWriter_Expecter) PutManifest(ctx interface{}, labels interface{}, payload interface{}) *MockRepositoryWriter_PutManifest_Call {
	return &MockRepositoryWriter_PutManifest_Call{Call: _e.mock.On("PutManifest", ctx, labels, payload)}
}

func (_c *MockRepositoryWriter_PutManifest_Call) Run(run func(ctx context.Context, labels map[string]string, payload any)) *MockRepositoryWriter_PutManifest_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 map[string]string
		if args[1] != nil {
			arg1 = args[1].(map[string]string)
		}
		var arg2 any
		if args[2] != nil {
			arg2 = args[2].(any)
		}
		run(
			arg0,
			arg1,
			arg2,
		)
	})
	return _c
}

func (_c *MockRepositoryWriter_PutManifest_Call) Return(iD manifest.ID, err error) *MockRepositoryWriter_PutManifest_Call {
	_c.Call.Return(iD, err)
	return _c
}

func (_c *MockRepositoryWriter_PutManifest_Call) RunAndReturn(run func(ctx context.Context, labels map[string]string, payload any) (manifest.ID, error)) *MockRepositoryWriter_PutManifest_Call {
	_c.Call.Return(run)
	return _c
}

// Refresh provides a mock function for the type MockRepositoryWriter
func (_mock *MockRepositoryWriter) Refresh(ctx context.Context) error {
	ret := _mock.Called(ctx)

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

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

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

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

func (_c *MockRepositoryWriter_Refresh_Call) Run(run func(ctx context.Context)) *MockRepositoryWriter_Refresh_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		run(
			arg0,
		)
	})
	return _c
}

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

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

// ReplaceManifests provides a mock function for the type MockRepositoryWriter
func (_mock *MockRepositoryWriter) ReplaceManifests(ctx context.Context, labels map[string]string, payload any) (manifest.ID, error) {
	ret := _mock.Called(ctx, labels, payload)

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

	var r0 manifest.ID
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, map[string]string, any) (manifest.ID, error)); ok {
		return returnFunc(ctx, labels, payload)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, map[string]string, any) manifest.ID); ok {
		r0 = returnFunc(ctx, labels, payload)
	} else {
		r0 = ret.Get(0).(manifest.ID)
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, map[string]string, any) error); ok {
		r1 = returnFunc(ctx, labels, payload)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// ReplaceManifests is a helper method to define mock.On call
//   - ctx context.Context
//   - labels map[string]string
//   - payload any
func (_e *MockRepositoryWriter_Expecter) ReplaceManifests(ctx interface{}, labels interface{}, payload interface{}) *MockRepositoryWriter_ReplaceManifests_Call {
	return &MockRepositoryWriter_ReplaceManifests_Call{Call: _e.mock.On("ReplaceManifests", ctx, labels, payload)}
}

func (_c *MockRepositoryWriter_ReplaceManifests_Call) Run(run func(ctx context.Context, labels map[string]string, payload any)) *MockRepositoryWriter_ReplaceManifests_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 map[string]string
		if args[1] != nil {
			arg1 = args[1].(map[string]string)
		}
		var arg2 any
		if args[2] != nil {
			arg2 = args[2].(any)
		}
		run(
			arg0,
			arg1,
			arg2,
		)
	})
	return _c
}

func (_c *MockRepositoryWriter_ReplaceManifests_Call) Return(iD manifest.ID, err error) *MockRepositoryWriter_ReplaceManifests_Call {
	_c.Call.Return(iD, err)
	return _c
}

func (_c *MockRepositoryWriter_ReplaceManifests_Call) RunAndReturn(run func(ctx context.Context, labels map[string]string, payload any) (manifest.ID, error)) *MockRepositoryWriter_ReplaceManifests_Call {
	_c.Call.Return(run)
	return _c
}

// Time provides a mock function for the type MockRepositoryWriter
func (_mock *MockRepositoryWriter) Time() time.Time {
	ret := _mock.Called()

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

	var r0 time.Time
	if returnFunc, ok := ret.Get(0).(func() time.Time); ok {
		r0 = returnFunc()
	} else {
		r0 = ret.Get(0).(time.Time)
	}
	return r0
}

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

// Time is a helper method to define mock.On call
func (_e *MockRepositoryWriter_Expecter) Time() *MockRepositoryWriter_Time_Call {
	return &MockRepositoryWriter_Time_Call{Call: _e.mock.On("Time")}
}

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

func (_c *MockRepositoryWriter_Time_Call) Return(time1 time.Time) *MockRepositoryWriter_Time_Call {
	_c.Call.Return(time1)
	return _c
}

func (_c *MockRepositoryWriter_Time_Call) RunAndReturn(run func() time.Time) *MockRepositoryWriter_Time_Call {
	_c.Call.Return(run)
	return _c
}

// UpdateDescription provides a mock function for the type MockRepositoryWriter
func (_mock *MockRepositoryWriter) UpdateDescription(d string) {
	_mock.Called(d)
	return
}

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

// UpdateDescription is a helper method to define mock.On call
//   - d string
func (_e *MockRepositoryWriter_Expecter) UpdateDescription(d interface{}) *MockRepositoryWriter_UpdateDescription_Call {
	return &MockRepositoryWriter_UpdateDescription_Call{Call: _e.mock.On("UpdateDescription", d)}
}

func (_c *MockRepositoryWriter_UpdateDescription_Call) Run(run func(d string)) *MockRepositoryWriter_UpdateDescription_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 string
		if args[0] != nil {
			arg0 = args[0].(string)
		}
		run(
			arg0,
		)
	})
	return _c
}

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

func (_c *MockRepositoryWriter_UpdateDescription_Call) RunAndReturn(run func(d string)) *MockRepositoryWriter_UpdateDescription_Call {
	_c.Run(run)
	return _c
}

// VerifyObject provides a mock function for the type MockRepositoryWriter
func (_mock *MockRepositoryWriter) VerifyObject(ctx context.Context, id object.ID) ([]content.ID, error) {
	ret := _mock.Called(ctx, id)

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

	var r0 []content.ID
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, object.ID) ([]content.ID, error)); ok {
		return returnFunc(ctx, id)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, object.ID) []content.ID); ok {
		r0 = returnFunc(ctx, id)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]content.ID)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, object.ID) error); ok {
		r1 = returnFunc(ctx, id)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// VerifyObject is a helper method to define mock.On call
//   - ctx context.Context
//   - id object.ID
func (_e *MockRepositoryWriter_Expecter) VerifyObject(ctx interface{}, id interface{}) *MockRepositoryWriter_VerifyObject_Call {
	return &MockRepositoryWriter_VerifyObject_Call{Call: _e.mock.On("VerifyObject", ctx, id)}
}

func (_c *MockRepositoryWriter_VerifyObject_Call) Run(run func(ctx context.Context, id object.ID)) *MockRepositoryWriter_VerifyObject_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 object.ID
		if args[1] != nil {
			arg1 = args[1].(object.ID)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *MockRepositoryWriter_VerifyObject_Call) Return(vs []content.ID, err error) *MockRepositoryWriter_VerifyObject_Call {
	_c.Call.Return(vs, err)
	return _c
}

func (_c *MockRepositoryWriter_VerifyObject_Call) RunAndReturn(run func(ctx context.Context, id object.ID) ([]content.ID, error)) *MockRepositoryWriter_VerifyObject_Call {
	_c.Call.Return(run)
	return _c
}
