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

package portsmocks

import (
	"context"

	"github.com/bnema/vev/internal/domain"
	"github.com/bnema/vev/internal/ports"
	mock "github.com/stretchr/testify/mock"
)

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

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

	return mock
}

// MockCatalogue is an autogenerated mock type for the Catalogue type
type MockCatalogue struct {
	mock.Mock
}

type MockCatalogue_Expecter struct {
	mock *mock.Mock
}

func (_m *MockCatalogue) EXPECT() *MockCatalogue_Expecter {
	return &MockCatalogue_Expecter{mock: &_m.Mock}
}

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

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

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

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

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

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

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

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

// Create provides a mock function for the type MockCatalogue
func (_mock *MockCatalogue) Create(catalogueRecord domain.CatalogueRecord) error {
	ret := _mock.Called(catalogueRecord)

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

	var r0 error
	if returnFunc, ok := ret.Get(0).(func(domain.CatalogueRecord) error); ok {
		r0 = returnFunc(catalogueRecord)
	} else {
		r0 = ret.Error(0)
	}
	return r0
}

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

// Create is a helper method to define mock.On call
//   - catalogueRecord domain.CatalogueRecord
func (_e *MockCatalogue_Expecter) Create(catalogueRecord any) *MockCatalogue_Create_Call {
	return &MockCatalogue_Create_Call{Call: _e.mock.On("Create", catalogueRecord)}
}

func (_c *MockCatalogue_Create_Call) Run(run func(catalogueRecord domain.CatalogueRecord)) *MockCatalogue_Create_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 domain.CatalogueRecord
		if args[0] != nil {
			arg0 = args[0].(domain.CatalogueRecord)
		}
		run(
			arg0,
		)
	})
	return _c
}

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

func (_c *MockCatalogue_Create_Call) RunAndReturn(run func(catalogueRecord domain.CatalogueRecord) error) *MockCatalogue_Create_Call {
	_c.Call.Return(run)
	return _c
}

// Delete provides a mock function for the type MockCatalogue
func (_mock *MockCatalogue) Delete(s string) error {
	ret := _mock.Called(s)

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

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

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

// Delete is a helper method to define mock.On call
//   - s string
func (_e *MockCatalogue_Expecter) Delete(s any) *MockCatalogue_Delete_Call {
	return &MockCatalogue_Delete_Call{Call: _e.mock.On("Delete", s)}
}

func (_c *MockCatalogue_Delete_Call) Run(run func(s string)) *MockCatalogue_Delete_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 *MockCatalogue_Delete_Call) Return(err error) *MockCatalogue_Delete_Call {
	_c.Call.Return(err)
	return _c
}

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

// Record provides a mock function for the type MockCatalogue
func (_mock *MockCatalogue) Record(s string) (domain.CatalogueRecord, bool, error) {
	ret := _mock.Called(s)

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

	var r0 domain.CatalogueRecord
	var r1 bool
	var r2 error
	if returnFunc, ok := ret.Get(0).(func(string) (domain.CatalogueRecord, bool, error)); ok {
		return returnFunc(s)
	}
	if returnFunc, ok := ret.Get(0).(func(string) domain.CatalogueRecord); ok {
		r0 = returnFunc(s)
	} else {
		r0 = ret.Get(0).(domain.CatalogueRecord)
	}
	if returnFunc, ok := ret.Get(1).(func(string) bool); ok {
		r1 = returnFunc(s)
	} else {
		r1 = ret.Get(1).(bool)
	}
	if returnFunc, ok := ret.Get(2).(func(string) error); ok {
		r2 = returnFunc(s)
	} else {
		r2 = ret.Error(2)
	}
	return r0, r1, r2
}

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

// Record is a helper method to define mock.On call
//   - s string
func (_e *MockCatalogue_Expecter) Record(s any) *MockCatalogue_Record_Call {
	return &MockCatalogue_Record_Call{Call: _e.mock.On("Record", s)}
}

func (_c *MockCatalogue_Record_Call) Run(run func(s string)) *MockCatalogue_Record_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 *MockCatalogue_Record_Call) Return(catalogueRecord domain.CatalogueRecord, b bool, err error) *MockCatalogue_Record_Call {
	_c.Call.Return(catalogueRecord, b, err)
	return _c
}

func (_c *MockCatalogue_Record_Call) RunAndReturn(run func(s string) (domain.CatalogueRecord, bool, error)) *MockCatalogue_Record_Call {
	_c.Call.Return(run)
	return _c
}

// Records provides a mock function for the type MockCatalogue
func (_mock *MockCatalogue) Records() ([]domain.CatalogueRecord, error) {
	ret := _mock.Called()

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

	var r0 []domain.CatalogueRecord
	var r1 error
	if returnFunc, ok := ret.Get(0).(func() ([]domain.CatalogueRecord, error)); ok {
		return returnFunc()
	}
	if returnFunc, ok := ret.Get(0).(func() []domain.CatalogueRecord); ok {
		r0 = returnFunc()
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]domain.CatalogueRecord)
		}
	}
	if returnFunc, ok := ret.Get(1).(func() error); ok {
		r1 = returnFunc()
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// Records is a helper method to define mock.On call
func (_e *MockCatalogue_Expecter) Records() *MockCatalogue_Records_Call {
	return &MockCatalogue_Records_Call{Call: _e.mock.On("Records")}
}

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

func (_c *MockCatalogue_Records_Call) Return(catalogueRecords []domain.CatalogueRecord, err error) *MockCatalogue_Records_Call {
	_c.Call.Return(catalogueRecords, err)
	return _c
}

func (_c *MockCatalogue_Records_Call) RunAndReturn(run func() ([]domain.CatalogueRecord, error)) *MockCatalogue_Records_Call {
	_c.Call.Return(run)
	return _c
}

// Rename provides a mock function for the type MockCatalogue
func (_mock *MockCatalogue) Rename(s string, catalogueRecord domain.CatalogueRecord) error {
	ret := _mock.Called(s, catalogueRecord)

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

	var r0 error
	if returnFunc, ok := ret.Get(0).(func(string, domain.CatalogueRecord) error); ok {
		r0 = returnFunc(s, catalogueRecord)
	} else {
		r0 = ret.Error(0)
	}
	return r0
}

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

// Rename is a helper method to define mock.On call
//   - s string
//   - catalogueRecord domain.CatalogueRecord
func (_e *MockCatalogue_Expecter) Rename(s any, catalogueRecord any) *MockCatalogue_Rename_Call {
	return &MockCatalogue_Rename_Call{Call: _e.mock.On("Rename", s, catalogueRecord)}
}

func (_c *MockCatalogue_Rename_Call) Run(run func(s string, catalogueRecord domain.CatalogueRecord)) *MockCatalogue_Rename_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 string
		if args[0] != nil {
			arg0 = args[0].(string)
		}
		var arg1 domain.CatalogueRecord
		if args[1] != nil {
			arg1 = args[1].(domain.CatalogueRecord)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

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

func (_c *MockCatalogue_Rename_Call) RunAndReturn(run func(s string, catalogueRecord domain.CatalogueRecord) error) *MockCatalogue_Rename_Call {
	_c.Call.Return(run)
	return _c
}

// Replace provides a mock function for the type MockCatalogue
func (_mock *MockCatalogue) Replace(s string, catalogueRecord domain.CatalogueRecord) error {
	ret := _mock.Called(s, catalogueRecord)

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

	var r0 error
	if returnFunc, ok := ret.Get(0).(func(string, domain.CatalogueRecord) error); ok {
		r0 = returnFunc(s, catalogueRecord)
	} else {
		r0 = ret.Error(0)
	}
	return r0
}

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

// Replace is a helper method to define mock.On call
//   - s string
//   - catalogueRecord domain.CatalogueRecord
func (_e *MockCatalogue_Expecter) Replace(s any, catalogueRecord any) *MockCatalogue_Replace_Call {
	return &MockCatalogue_Replace_Call{Call: _e.mock.On("Replace", s, catalogueRecord)}
}

func (_c *MockCatalogue_Replace_Call) Run(run func(s string, catalogueRecord domain.CatalogueRecord)) *MockCatalogue_Replace_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 string
		if args[0] != nil {
			arg0 = args[0].(string)
		}
		var arg1 domain.CatalogueRecord
		if args[1] != nil {
			arg1 = args[1].(domain.CatalogueRecord)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

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

func (_c *MockCatalogue_Replace_Call) RunAndReturn(run func(s string, catalogueRecord domain.CatalogueRecord) error) *MockCatalogue_Replace_Call {
	_c.Call.Return(run)
	return _c
}

// Sync provides a mock function for the type MockCatalogue
func (_mock *MockCatalogue) Sync() error {
	ret := _mock.Called()

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

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

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

// Sync is a helper method to define mock.On call
func (_e *MockCatalogue_Expecter) Sync() *MockCatalogue_Sync_Call {
	return &MockCatalogue_Sync_Call{Call: _e.mock.On("Sync")}
}

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

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

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

// UpdateMetadata provides a mock function for the type MockCatalogue
func (_mock *MockCatalogue) UpdateMetadata(catalogueMetadataUpdate domain.CatalogueMetadataUpdate) error {
	ret := _mock.Called(catalogueMetadataUpdate)

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

	var r0 error
	if returnFunc, ok := ret.Get(0).(func(domain.CatalogueMetadataUpdate) error); ok {
		r0 = returnFunc(catalogueMetadataUpdate)
	} else {
		r0 = ret.Error(0)
	}
	return r0
}

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

// UpdateMetadata is a helper method to define mock.On call
//   - catalogueMetadataUpdate domain.CatalogueMetadataUpdate
func (_e *MockCatalogue_Expecter) UpdateMetadata(catalogueMetadataUpdate any) *MockCatalogue_UpdateMetadata_Call {
	return &MockCatalogue_UpdateMetadata_Call{Call: _e.mock.On("UpdateMetadata", catalogueMetadataUpdate)}
}

func (_c *MockCatalogue_UpdateMetadata_Call) Run(run func(catalogueMetadataUpdate domain.CatalogueMetadataUpdate)) *MockCatalogue_UpdateMetadata_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 domain.CatalogueMetadataUpdate
		if args[0] != nil {
			arg0 = args[0].(domain.CatalogueMetadataUpdate)
		}
		run(
			arg0,
		)
	})
	return _c
}

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

func (_c *MockCatalogue_UpdateMetadata_Call) RunAndReturn(run func(catalogueMetadataUpdate domain.CatalogueMetadataUpdate) error) *MockCatalogue_UpdateMetadata_Call {
	_c.Call.Return(run)
	return _c
}

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

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

	return mock
}

// MockSnapshotRepository is an autogenerated mock type for the SnapshotRepository type
type MockSnapshotRepository struct {
	mock.Mock
}

type MockSnapshotRepository_Expecter struct {
	mock *mock.Mock
}

func (_m *MockSnapshotRepository) EXPECT() *MockSnapshotRepository_Expecter {
	return &MockSnapshotRepository_Expecter{mock: &_m.Mock}
}

// CollectGarbage provides a mock function for the type MockSnapshotRepository
func (_mock *MockSnapshotRepository) CollectGarbage(context1 context.Context, incarnationIDToCheckpointRef map[domain.IncarnationID]domain.CheckpointRef) error {
	ret := _mock.Called(context1, incarnationIDToCheckpointRef)

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

	var r0 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, map[domain.IncarnationID]domain.CheckpointRef) error); ok {
		r0 = returnFunc(context1, incarnationIDToCheckpointRef)
	} else {
		r0 = ret.Error(0)
	}
	return r0
}

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

// CollectGarbage is a helper method to define mock.On call
//   - context1 context.Context
//   - incarnationIDToCheckpointRef map[domain.IncarnationID]domain.CheckpointRef
func (_e *MockSnapshotRepository_Expecter) CollectGarbage(context1 any, incarnationIDToCheckpointRef any) *MockSnapshotRepository_CollectGarbage_Call {
	return &MockSnapshotRepository_CollectGarbage_Call{Call: _e.mock.On("CollectGarbage", context1, incarnationIDToCheckpointRef)}
}

func (_c *MockSnapshotRepository_CollectGarbage_Call) Run(run func(context1 context.Context, incarnationIDToCheckpointRef map[domain.IncarnationID]domain.CheckpointRef)) *MockSnapshotRepository_CollectGarbage_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 map[domain.IncarnationID]domain.CheckpointRef
		if args[1] != nil {
			arg1 = args[1].(map[domain.IncarnationID]domain.CheckpointRef)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

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

func (_c *MockSnapshotRepository_CollectGarbage_Call) RunAndReturn(run func(context1 context.Context, incarnationIDToCheckpointRef map[domain.IncarnationID]domain.CheckpointRef) error) *MockSnapshotRepository_CollectGarbage_Call {
	_c.Call.Return(run)
	return _c
}

// DeleteIncarnation provides a mock function for the type MockSnapshotRepository
func (_mock *MockSnapshotRepository) DeleteIncarnation(context1 context.Context, incarnationID domain.IncarnationID) error {
	ret := _mock.Called(context1, incarnationID)

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

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

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

// DeleteIncarnation is a helper method to define mock.On call
//   - context1 context.Context
//   - incarnationID domain.IncarnationID
func (_e *MockSnapshotRepository_Expecter) DeleteIncarnation(context1 any, incarnationID any) *MockSnapshotRepository_DeleteIncarnation_Call {
	return &MockSnapshotRepository_DeleteIncarnation_Call{Call: _e.mock.On("DeleteIncarnation", context1, incarnationID)}
}

func (_c *MockSnapshotRepository_DeleteIncarnation_Call) Run(run func(context1 context.Context, incarnationID domain.IncarnationID)) *MockSnapshotRepository_DeleteIncarnation_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 domain.IncarnationID
		if args[1] != nil {
			arg1 = args[1].(domain.IncarnationID)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

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

func (_c *MockSnapshotRepository_DeleteIncarnation_Call) RunAndReturn(run func(context1 context.Context, incarnationID domain.IncarnationID) error) *MockSnapshotRepository_DeleteIncarnation_Call {
	_c.Call.Return(run)
	return _c
}

// LoadCheckpoint provides a mock function for the type MockSnapshotRepository
func (_mock *MockSnapshotRepository) LoadCheckpoint(context1 context.Context, incarnationID domain.IncarnationID, s string, v ports.CheckpointRef) (ports.SnapshotGeneration, error) {
	ret := _mock.Called(context1, incarnationID, s, v)

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

	var r0 ports.SnapshotGeneration
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, domain.IncarnationID, string, ports.CheckpointRef) (ports.SnapshotGeneration, error)); ok {
		return returnFunc(context1, incarnationID, s, v)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, domain.IncarnationID, string, ports.CheckpointRef) ports.SnapshotGeneration); ok {
		r0 = returnFunc(context1, incarnationID, s, v)
	} else {
		r0 = ret.Get(0).(ports.SnapshotGeneration)
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, domain.IncarnationID, string, ports.CheckpointRef) error); ok {
		r1 = returnFunc(context1, incarnationID, s, v)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// LoadCheckpoint is a helper method to define mock.On call
//   - context1 context.Context
//   - incarnationID domain.IncarnationID
//   - s string
//   - v ports.CheckpointRef
func (_e *MockSnapshotRepository_Expecter) LoadCheckpoint(context1 any, incarnationID any, s any, v any) *MockSnapshotRepository_LoadCheckpoint_Call {
	return &MockSnapshotRepository_LoadCheckpoint_Call{Call: _e.mock.On("LoadCheckpoint", context1, incarnationID, s, v)}
}

func (_c *MockSnapshotRepository_LoadCheckpoint_Call) Run(run func(context1 context.Context, incarnationID domain.IncarnationID, s string, v ports.CheckpointRef)) *MockSnapshotRepository_LoadCheckpoint_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 domain.IncarnationID
		if args[1] != nil {
			arg1 = args[1].(domain.IncarnationID)
		}
		var arg2 string
		if args[2] != nil {
			arg2 = args[2].(string)
		}
		var arg3 ports.CheckpointRef
		if args[3] != nil {
			arg3 = args[3].(ports.CheckpointRef)
		}
		run(
			arg0,
			arg1,
			arg2,
			arg3,
		)
	})
	return _c
}

func (_c *MockSnapshotRepository_LoadCheckpoint_Call) Return(snapshotGeneration ports.SnapshotGeneration, err error) *MockSnapshotRepository_LoadCheckpoint_Call {
	_c.Call.Return(snapshotGeneration, err)
	return _c
}

func (_c *MockSnapshotRepository_LoadCheckpoint_Call) RunAndReturn(run func(context1 context.Context, incarnationID domain.IncarnationID, s string, v ports.CheckpointRef) (ports.SnapshotGeneration, error)) *MockSnapshotRepository_LoadCheckpoint_Call {
	_c.Call.Return(run)
	return _c
}

// Publish provides a mock function for the type MockSnapshotRepository
func (_mock *MockSnapshotRepository) Publish(context1 context.Context, snapshotPublication ports.SnapshotPublication) error {
	ret := _mock.Called(context1, snapshotPublication)

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

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

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

// Publish is a helper method to define mock.On call
//   - context1 context.Context
//   - snapshotPublication ports.SnapshotPublication
func (_e *MockSnapshotRepository_Expecter) Publish(context1 any, snapshotPublication any) *MockSnapshotRepository_Publish_Call {
	return &MockSnapshotRepository_Publish_Call{Call: _e.mock.On("Publish", context1, snapshotPublication)}
}

func (_c *MockSnapshotRepository_Publish_Call) Run(run func(context1 context.Context, snapshotPublication ports.SnapshotPublication)) *MockSnapshotRepository_Publish_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 ports.SnapshotPublication
		if args[1] != nil {
			arg1 = args[1].(ports.SnapshotPublication)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

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

func (_c *MockSnapshotRepository_Publish_Call) RunAndReturn(run func(context1 context.Context, snapshotPublication ports.SnapshotPublication) error) *MockSnapshotRepository_Publish_Call {
	_c.Call.Return(run)
	return _c
}

// ReconcileCheckpoint provides a mock function for the type MockSnapshotRepository
func (_mock *MockSnapshotRepository) ReconcileCheckpoint(context1 context.Context, incarnationID domain.IncarnationID, v ports.CheckpointRef) error {
	ret := _mock.Called(context1, incarnationID, v)

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

	var r0 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, domain.IncarnationID, ports.CheckpointRef) error); ok {
		r0 = returnFunc(context1, incarnationID, v)
	} else {
		r0 = ret.Error(0)
	}
	return r0
}

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

// ReconcileCheckpoint is a helper method to define mock.On call
//   - context1 context.Context
//   - incarnationID domain.IncarnationID
//   - v ports.CheckpointRef
func (_e *MockSnapshotRepository_Expecter) ReconcileCheckpoint(context1 any, incarnationID any, v any) *MockSnapshotRepository_ReconcileCheckpoint_Call {
	return &MockSnapshotRepository_ReconcileCheckpoint_Call{Call: _e.mock.On("ReconcileCheckpoint", context1, incarnationID, v)}
}

func (_c *MockSnapshotRepository_ReconcileCheckpoint_Call) Run(run func(context1 context.Context, incarnationID domain.IncarnationID, v ports.CheckpointRef)) *MockSnapshotRepository_ReconcileCheckpoint_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 domain.IncarnationID
		if args[1] != nil {
			arg1 = args[1].(domain.IncarnationID)
		}
		var arg2 ports.CheckpointRef
		if args[2] != nil {
			arg2 = args[2].(ports.CheckpointRef)
		}
		run(
			arg0,
			arg1,
			arg2,
		)
	})
	return _c
}

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

func (_c *MockSnapshotRepository_ReconcileCheckpoint_Call) RunAndReturn(run func(context1 context.Context, incarnationID domain.IncarnationID, v ports.CheckpointRef) error) *MockSnapshotRepository_ReconcileCheckpoint_Call {
	_c.Call.Return(run)
	return _c
}