// Code generated by MockGen. DO NOT EDIT.
// Source: gitlab.com/gitlab-org/cluster-integration/gitlab-agent/v18/internal/gitaly (interfaces: PoolInterface,FetchVisitor,PathEntryVisitor,FileVisitor,PathFetcherInterface,PollerInterface)
//
// Generated by this command:
//
//	mockgen -typed -destination internalgitaly.go -package mock_internalgitaly gitlab.com/gitlab-org/cluster-integration/gitlab-agent/v18/internal/gitaly PoolInterface,FetchVisitor,PathEntryVisitor,FileVisitor,PathFetcherInterface,PollerInterface
//

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

import (
	context "context"
	reflect "reflect"

	gitaly "gitlab.com/gitlab-org/cluster-integration/gitlab-agent/v18/internal/gitaly"
	gitalypb "gitlab.com/gitlab-org/cluster-integration/gitlab-agent/v18/internal/gitaly/vendored/gitalypb"
	entity "gitlab.com/gitlab-org/cluster-integration/gitlab-agent/v18/pkg/entity"
	gomock "go.uber.org/mock/gomock"
)

// MockPoolInterface is a mock of PoolInterface interface.
type MockPoolInterface struct {
	ctrl     *gomock.Controller
	recorder *MockPoolInterfaceMockRecorder
	isgomock struct{}
}

// MockPoolInterfaceMockRecorder is the mock recorder for MockPoolInterface.
type MockPoolInterfaceMockRecorder struct {
	mock *MockPoolInterface
}

// NewMockPoolInterface creates a new mock instance.
func NewMockPoolInterface(ctrl *gomock.Controller) *MockPoolInterface {
	mock := &MockPoolInterface{ctrl: ctrl}
	mock.recorder = &MockPoolInterfaceMockRecorder{mock}
	return mock
}

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

// PathFetcher mocks base method.
func (m *MockPoolInterface) PathFetcher(arg0 context.Context, arg1 *entity.GitalyInfo) (gitaly.PathFetcherInterface, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "PathFetcher", arg0, arg1)
	ret0, _ := ret[0].(gitaly.PathFetcherInterface)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// PathFetcher indicates an expected call of PathFetcher.
func (mr *MockPoolInterfaceMockRecorder) PathFetcher(arg0, arg1 any) *MockPoolInterfacePathFetcherCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PathFetcher", reflect.TypeOf((*MockPoolInterface)(nil).PathFetcher), arg0, arg1)
	return &MockPoolInterfacePathFetcherCall{Call: call}
}

// MockPoolInterfacePathFetcherCall wrap *gomock.Call
type MockPoolInterfacePathFetcherCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockPoolInterfacePathFetcherCall) Return(arg0 gitaly.PathFetcherInterface, arg1 error) *MockPoolInterfacePathFetcherCall {
	c.Call = c.Call.Return(arg0, arg1)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockPoolInterfacePathFetcherCall) Do(f func(context.Context, *entity.GitalyInfo) (gitaly.PathFetcherInterface, error)) *MockPoolInterfacePathFetcherCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockPoolInterfacePathFetcherCall) DoAndReturn(f func(context.Context, *entity.GitalyInfo) (gitaly.PathFetcherInterface, error)) *MockPoolInterfacePathFetcherCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// Poller mocks base method.
func (m *MockPoolInterface) Poller(arg0 context.Context, arg1 *entity.GitalyInfo) (gitaly.PollerInterface, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Poller", arg0, arg1)
	ret0, _ := ret[0].(gitaly.PollerInterface)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Poller indicates an expected call of Poller.
func (mr *MockPoolInterfaceMockRecorder) Poller(arg0, arg1 any) *MockPoolInterfacePollerCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Poller", reflect.TypeOf((*MockPoolInterface)(nil).Poller), arg0, arg1)
	return &MockPoolInterfacePollerCall{Call: call}
}

// MockPoolInterfacePollerCall wrap *gomock.Call
type MockPoolInterfacePollerCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockPoolInterfacePollerCall) Return(arg0 gitaly.PollerInterface, arg1 error) *MockPoolInterfacePollerCall {
	c.Call = c.Call.Return(arg0, arg1)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockPoolInterfacePollerCall) Do(f func(context.Context, *entity.GitalyInfo) (gitaly.PollerInterface, error)) *MockPoolInterfacePollerCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockPoolInterfacePollerCall) DoAndReturn(f func(context.Context, *entity.GitalyInfo) (gitaly.PollerInterface, error)) *MockPoolInterfacePollerCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// MockFetchVisitor is a mock of FetchVisitor interface.
type MockFetchVisitor struct {
	ctrl     *gomock.Controller
	recorder *MockFetchVisitorMockRecorder
	isgomock struct{}
}

// MockFetchVisitorMockRecorder is the mock recorder for MockFetchVisitor.
type MockFetchVisitorMockRecorder struct {
	mock *MockFetchVisitor
}

// NewMockFetchVisitor creates a new mock instance.
func NewMockFetchVisitor(ctrl *gomock.Controller) *MockFetchVisitor {
	mock := &MockFetchVisitor{ctrl: ctrl}
	mock.recorder = &MockFetchVisitorMockRecorder{mock}
	return mock
}

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

// Entry mocks base method.
func (m *MockFetchVisitor) Entry(arg0 *gitalypb.TreeEntry) (bool, int64, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Entry", arg0)
	ret0, _ := ret[0].(bool)
	ret1, _ := ret[1].(int64)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// Entry indicates an expected call of Entry.
func (mr *MockFetchVisitorMockRecorder) Entry(arg0 any) *MockFetchVisitorEntryCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Entry", reflect.TypeOf((*MockFetchVisitor)(nil).Entry), arg0)
	return &MockFetchVisitorEntryCall{Call: call}
}

// MockFetchVisitorEntryCall wrap *gomock.Call
type MockFetchVisitorEntryCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockFetchVisitorEntryCall) Return(arg0 bool, arg1 int64, arg2 error) *MockFetchVisitorEntryCall {
	c.Call = c.Call.Return(arg0, arg1, arg2)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockFetchVisitorEntryCall) Do(f func(*gitalypb.TreeEntry) (bool, int64, error)) *MockFetchVisitorEntryCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockFetchVisitorEntryCall) DoAndReturn(f func(*gitalypb.TreeEntry) (bool, int64, error)) *MockFetchVisitorEntryCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// EntryDone mocks base method.
func (m *MockFetchVisitor) EntryDone(arg0 *gitalypb.TreeEntry, arg1 error) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "EntryDone", arg0, arg1)
}

// EntryDone indicates an expected call of EntryDone.
func (mr *MockFetchVisitorMockRecorder) EntryDone(arg0, arg1 any) *MockFetchVisitorEntryDoneCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EntryDone", reflect.TypeOf((*MockFetchVisitor)(nil).EntryDone), arg0, arg1)
	return &MockFetchVisitorEntryDoneCall{Call: call}
}

// MockFetchVisitorEntryDoneCall wrap *gomock.Call
type MockFetchVisitorEntryDoneCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockFetchVisitorEntryDoneCall) Return() *MockFetchVisitorEntryDoneCall {
	c.Call = c.Call.Return()
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockFetchVisitorEntryDoneCall) Do(f func(*gitalypb.TreeEntry, error)) *MockFetchVisitorEntryDoneCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockFetchVisitorEntryDoneCall) DoAndReturn(f func(*gitalypb.TreeEntry, error)) *MockFetchVisitorEntryDoneCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// StreamChunk mocks base method.
func (m *MockFetchVisitor) StreamChunk(path, data []byte) (bool, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "StreamChunk", path, data)
	ret0, _ := ret[0].(bool)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// StreamChunk indicates an expected call of StreamChunk.
func (mr *MockFetchVisitorMockRecorder) StreamChunk(path, data any) *MockFetchVisitorStreamChunkCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StreamChunk", reflect.TypeOf((*MockFetchVisitor)(nil).StreamChunk), path, data)
	return &MockFetchVisitorStreamChunkCall{Call: call}
}

// MockFetchVisitorStreamChunkCall wrap *gomock.Call
type MockFetchVisitorStreamChunkCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockFetchVisitorStreamChunkCall) Return(arg0 bool, arg1 error) *MockFetchVisitorStreamChunkCall {
	c.Call = c.Call.Return(arg0, arg1)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockFetchVisitorStreamChunkCall) Do(f func([]byte, []byte) (bool, error)) *MockFetchVisitorStreamChunkCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockFetchVisitorStreamChunkCall) DoAndReturn(f func([]byte, []byte) (bool, error)) *MockFetchVisitorStreamChunkCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// MockPathEntryVisitor is a mock of PathEntryVisitor interface.
type MockPathEntryVisitor struct {
	ctrl     *gomock.Controller
	recorder *MockPathEntryVisitorMockRecorder
	isgomock struct{}
}

// MockPathEntryVisitorMockRecorder is the mock recorder for MockPathEntryVisitor.
type MockPathEntryVisitorMockRecorder struct {
	mock *MockPathEntryVisitor
}

// NewMockPathEntryVisitor creates a new mock instance.
func NewMockPathEntryVisitor(ctrl *gomock.Controller) *MockPathEntryVisitor {
	mock := &MockPathEntryVisitor{ctrl: ctrl}
	mock.recorder = &MockPathEntryVisitorMockRecorder{mock}
	return mock
}

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

// Entry mocks base method.
func (m *MockPathEntryVisitor) Entry(arg0 *gitalypb.TreeEntry) (bool, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Entry", arg0)
	ret0, _ := ret[0].(bool)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Entry indicates an expected call of Entry.
func (mr *MockPathEntryVisitorMockRecorder) Entry(arg0 any) *MockPathEntryVisitorEntryCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Entry", reflect.TypeOf((*MockPathEntryVisitor)(nil).Entry), arg0)
	return &MockPathEntryVisitorEntryCall{Call: call}
}

// MockPathEntryVisitorEntryCall wrap *gomock.Call
type MockPathEntryVisitorEntryCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockPathEntryVisitorEntryCall) Return(arg0 bool, arg1 error) *MockPathEntryVisitorEntryCall {
	c.Call = c.Call.Return(arg0, arg1)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockPathEntryVisitorEntryCall) Do(f func(*gitalypb.TreeEntry) (bool, error)) *MockPathEntryVisitorEntryCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockPathEntryVisitorEntryCall) DoAndReturn(f func(*gitalypb.TreeEntry) (bool, error)) *MockPathEntryVisitorEntryCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// MockFileVisitor is a mock of FileVisitor interface.
type MockFileVisitor struct {
	ctrl     *gomock.Controller
	recorder *MockFileVisitorMockRecorder
	isgomock struct{}
}

// MockFileVisitorMockRecorder is the mock recorder for MockFileVisitor.
type MockFileVisitorMockRecorder struct {
	mock *MockFileVisitor
}

// NewMockFileVisitor creates a new mock instance.
func NewMockFileVisitor(ctrl *gomock.Controller) *MockFileVisitor {
	mock := &MockFileVisitor{ctrl: ctrl}
	mock.recorder = &MockFileVisitorMockRecorder{mock}
	return mock
}

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

// Chunk mocks base method.
func (m *MockFileVisitor) Chunk(data []byte) (bool, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Chunk", data)
	ret0, _ := ret[0].(bool)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Chunk indicates an expected call of Chunk.
func (mr *MockFileVisitorMockRecorder) Chunk(data any) *MockFileVisitorChunkCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Chunk", reflect.TypeOf((*MockFileVisitor)(nil).Chunk), data)
	return &MockFileVisitorChunkCall{Call: call}
}

// MockFileVisitorChunkCall wrap *gomock.Call
type MockFileVisitorChunkCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockFileVisitorChunkCall) Return(arg0 bool, arg1 error) *MockFileVisitorChunkCall {
	c.Call = c.Call.Return(arg0, arg1)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockFileVisitorChunkCall) Do(f func([]byte) (bool, error)) *MockFileVisitorChunkCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockFileVisitorChunkCall) DoAndReturn(f func([]byte) (bool, error)) *MockFileVisitorChunkCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// MockPathFetcherInterface is a mock of PathFetcherInterface interface.
type MockPathFetcherInterface struct {
	ctrl     *gomock.Controller
	recorder *MockPathFetcherInterfaceMockRecorder
	isgomock struct{}
}

// MockPathFetcherInterfaceMockRecorder is the mock recorder for MockPathFetcherInterface.
type MockPathFetcherInterfaceMockRecorder struct {
	mock *MockPathFetcherInterface
}

// NewMockPathFetcherInterface creates a new mock instance.
func NewMockPathFetcherInterface(ctrl *gomock.Controller) *MockPathFetcherInterface {
	mock := &MockPathFetcherInterface{ctrl: ctrl}
	mock.recorder = &MockPathFetcherInterfaceMockRecorder{mock}
	return mock
}

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

// FetchFile mocks base method.
func (m *MockPathFetcherInterface) FetchFile(ctx context.Context, repo *gitalypb.Repository, revision, repoPath []byte, sizeLimit int64) ([]byte, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "FetchFile", ctx, repo, revision, repoPath, sizeLimit)
	ret0, _ := ret[0].([]byte)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// FetchFile indicates an expected call of FetchFile.
func (mr *MockPathFetcherInterfaceMockRecorder) FetchFile(ctx, repo, revision, repoPath, sizeLimit any) *MockPathFetcherInterfaceFetchFileCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FetchFile", reflect.TypeOf((*MockPathFetcherInterface)(nil).FetchFile), ctx, repo, revision, repoPath, sizeLimit)
	return &MockPathFetcherInterfaceFetchFileCall{Call: call}
}

// MockPathFetcherInterfaceFetchFileCall wrap *gomock.Call
type MockPathFetcherInterfaceFetchFileCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockPathFetcherInterfaceFetchFileCall) Return(arg0 []byte, arg1 error) *MockPathFetcherInterfaceFetchFileCall {
	c.Call = c.Call.Return(arg0, arg1)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockPathFetcherInterfaceFetchFileCall) Do(f func(context.Context, *gitalypb.Repository, []byte, []byte, int64) ([]byte, error)) *MockPathFetcherInterfaceFetchFileCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockPathFetcherInterfaceFetchFileCall) DoAndReturn(f func(context.Context, *gitalypb.Repository, []byte, []byte, int64) ([]byte, error)) *MockPathFetcherInterfaceFetchFileCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// StreamFile mocks base method.
func (m *MockPathFetcherInterface) StreamFile(ctx context.Context, repo *gitalypb.Repository, revision, repoPath []byte, sizeLimit int64, v gitaly.FileVisitor) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "StreamFile", ctx, repo, revision, repoPath, sizeLimit, v)
	ret0, _ := ret[0].(error)
	return ret0
}

// StreamFile indicates an expected call of StreamFile.
func (mr *MockPathFetcherInterfaceMockRecorder) StreamFile(ctx, repo, revision, repoPath, sizeLimit, v any) *MockPathFetcherInterfaceStreamFileCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StreamFile", reflect.TypeOf((*MockPathFetcherInterface)(nil).StreamFile), ctx, repo, revision, repoPath, sizeLimit, v)
	return &MockPathFetcherInterfaceStreamFileCall{Call: call}
}

// MockPathFetcherInterfaceStreamFileCall wrap *gomock.Call
type MockPathFetcherInterfaceStreamFileCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockPathFetcherInterfaceStreamFileCall) Return(arg0 error) *MockPathFetcherInterfaceStreamFileCall {
	c.Call = c.Call.Return(arg0)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockPathFetcherInterfaceStreamFileCall) Do(f func(context.Context, *gitalypb.Repository, []byte, []byte, int64, gitaly.FileVisitor) error) *MockPathFetcherInterfaceStreamFileCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockPathFetcherInterfaceStreamFileCall) DoAndReturn(f func(context.Context, *gitalypb.Repository, []byte, []byte, int64, gitaly.FileVisitor) error) *MockPathFetcherInterfaceStreamFileCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// Visit mocks base method.
func (m *MockPathFetcherInterface) Visit(ctx context.Context, repo *gitalypb.Repository, revision, repoPath []byte, recursive bool, visitor gitaly.FetchVisitor) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Visit", ctx, repo, revision, repoPath, recursive, visitor)
	ret0, _ := ret[0].(error)
	return ret0
}

// Visit indicates an expected call of Visit.
func (mr *MockPathFetcherInterfaceMockRecorder) Visit(ctx, repo, revision, repoPath, recursive, visitor any) *MockPathFetcherInterfaceVisitCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Visit", reflect.TypeOf((*MockPathFetcherInterface)(nil).Visit), ctx, repo, revision, repoPath, recursive, visitor)
	return &MockPathFetcherInterfaceVisitCall{Call: call}
}

// MockPathFetcherInterfaceVisitCall wrap *gomock.Call
type MockPathFetcherInterfaceVisitCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockPathFetcherInterfaceVisitCall) Return(arg0 error) *MockPathFetcherInterfaceVisitCall {
	c.Call = c.Call.Return(arg0)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockPathFetcherInterfaceVisitCall) Do(f func(context.Context, *gitalypb.Repository, []byte, []byte, bool, gitaly.FetchVisitor) error) *MockPathFetcherInterfaceVisitCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockPathFetcherInterfaceVisitCall) DoAndReturn(f func(context.Context, *gitalypb.Repository, []byte, []byte, bool, gitaly.FetchVisitor) error) *MockPathFetcherInterfaceVisitCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// VisitSingleFile mocks base method.
func (m *MockPathFetcherInterface) VisitSingleFile(ctx context.Context, repo *gitalypb.Repository, revision, repoPath []byte, visitor gitaly.FetchVisitor) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "VisitSingleFile", ctx, repo, revision, repoPath, visitor)
	ret0, _ := ret[0].(error)
	return ret0
}

// VisitSingleFile indicates an expected call of VisitSingleFile.
func (mr *MockPathFetcherInterfaceMockRecorder) VisitSingleFile(ctx, repo, revision, repoPath, visitor any) *MockPathFetcherInterfaceVisitSingleFileCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "VisitSingleFile", reflect.TypeOf((*MockPathFetcherInterface)(nil).VisitSingleFile), ctx, repo, revision, repoPath, visitor)
	return &MockPathFetcherInterfaceVisitSingleFileCall{Call: call}
}

// MockPathFetcherInterfaceVisitSingleFileCall wrap *gomock.Call
type MockPathFetcherInterfaceVisitSingleFileCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockPathFetcherInterfaceVisitSingleFileCall) Return(arg0 error) *MockPathFetcherInterfaceVisitSingleFileCall {
	c.Call = c.Call.Return(arg0)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockPathFetcherInterfaceVisitSingleFileCall) Do(f func(context.Context, *gitalypb.Repository, []byte, []byte, gitaly.FetchVisitor) error) *MockPathFetcherInterfaceVisitSingleFileCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockPathFetcherInterfaceVisitSingleFileCall) DoAndReturn(f func(context.Context, *gitalypb.Repository, []byte, []byte, gitaly.FetchVisitor) error) *MockPathFetcherInterfaceVisitSingleFileCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// MockPollerInterface is a mock of PollerInterface interface.
type MockPollerInterface struct {
	ctrl     *gomock.Controller
	recorder *MockPollerInterfaceMockRecorder
	isgomock struct{}
}

// MockPollerInterfaceMockRecorder is the mock recorder for MockPollerInterface.
type MockPollerInterfaceMockRecorder struct {
	mock *MockPollerInterface
}

// NewMockPollerInterface creates a new mock instance.
func NewMockPollerInterface(ctrl *gomock.Controller) *MockPollerInterface {
	mock := &MockPollerInterface{ctrl: ctrl}
	mock.recorder = &MockPollerInterfaceMockRecorder{mock}
	return mock
}

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

// Poll mocks base method.
func (m *MockPollerInterface) Poll(ctx context.Context, repo *gitalypb.Repository, refName, filepath string) (*gitaly.PollInfo, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Poll", ctx, repo, refName, filepath)
	ret0, _ := ret[0].(*gitaly.PollInfo)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Poll indicates an expected call of Poll.
func (mr *MockPollerInterfaceMockRecorder) Poll(ctx, repo, refName, filepath any) *MockPollerInterfacePollCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Poll", reflect.TypeOf((*MockPollerInterface)(nil).Poll), ctx, repo, refName, filepath)
	return &MockPollerInterfacePollCall{Call: call}
}

// MockPollerInterfacePollCall wrap *gomock.Call
type MockPollerInterfacePollCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockPollerInterfacePollCall) Return(arg0 *gitaly.PollInfo, arg1 error) *MockPollerInterfacePollCall {
	c.Call = c.Call.Return(arg0, arg1)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockPollerInterfacePollCall) Do(f func(context.Context, *gitalypb.Repository, string, string) (*gitaly.PollInfo, error)) *MockPollerInterfacePollCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockPollerInterfacePollCall) DoAndReturn(f func(context.Context, *gitalypb.Repository, string, string) (*gitaly.PollInfo, error)) *MockPollerInterfacePollCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}
