// Code generated by MockGen. DO NOT EDIT.
// Source: ../../../gitaly/vendored/gitalypb/commit_grpc.pb.go
//
// Generated by this command:
//
//	mockgen -typed -source ../../../gitaly/vendored/gitalypb/commit_grpc.pb.go -destination gitaly.go -package mock_gitaly
//

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

import (
	context "context"
	reflect "reflect"

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

// MockCommitServiceClient is a mock of CommitServiceClient interface.
type MockCommitServiceClient struct {
	ctrl     *gomock.Controller
	recorder *MockCommitServiceClientMockRecorder
	isgomock struct{}
}

// MockCommitServiceClientMockRecorder is the mock recorder for MockCommitServiceClient.
type MockCommitServiceClientMockRecorder struct {
	mock *MockCommitServiceClient
}

// NewMockCommitServiceClient creates a new mock instance.
func NewMockCommitServiceClient(ctrl *gomock.Controller) *MockCommitServiceClient {
	mock := &MockCommitServiceClient{ctrl: ctrl}
	mock.recorder = &MockCommitServiceClientMockRecorder{mock}
	return mock
}

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

// CheckObjectsExist mocks base method.
func (m *MockCommitServiceClient) CheckObjectsExist(ctx context.Context, opts ...grpc.CallOption) (grpc.BidiStreamingClient[gitalypb.CheckObjectsExistRequest, gitalypb.CheckObjectsExistResponse], error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "CheckObjectsExist", varargs...)
	ret0, _ := ret[0].(grpc.BidiStreamingClient[gitalypb.CheckObjectsExistRequest, gitalypb.CheckObjectsExistResponse])
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CheckObjectsExist indicates an expected call of CheckObjectsExist.
func (mr *MockCommitServiceClientMockRecorder) CheckObjectsExist(ctx any, opts ...any) *MockCommitServiceClientCheckObjectsExistCall {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx}, opts...)
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CheckObjectsExist", reflect.TypeOf((*MockCommitServiceClient)(nil).CheckObjectsExist), varargs...)
	return &MockCommitServiceClientCheckObjectsExistCall{Call: call}
}

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

// Return rewrite *gomock.Call.Return
func (c *MockCommitServiceClientCheckObjectsExistCall) Return(arg0 grpc.BidiStreamingClient[gitalypb.CheckObjectsExistRequest, gitalypb.CheckObjectsExistResponse], arg1 error) *MockCommitServiceClientCheckObjectsExistCall {
	c.Call = c.Call.Return(arg0, arg1)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockCommitServiceClientCheckObjectsExistCall) Do(f func(context.Context, ...grpc.CallOption) (grpc.BidiStreamingClient[gitalypb.CheckObjectsExistRequest, gitalypb.CheckObjectsExistResponse], error)) *MockCommitServiceClientCheckObjectsExistCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockCommitServiceClientCheckObjectsExistCall) DoAndReturn(f func(context.Context, ...grpc.CallOption) (grpc.BidiStreamingClient[gitalypb.CheckObjectsExistRequest, gitalypb.CheckObjectsExistResponse], error)) *MockCommitServiceClientCheckObjectsExistCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// CommitIsAncestor mocks base method.
func (m *MockCommitServiceClient) CommitIsAncestor(ctx context.Context, in *gitalypb.CommitIsAncestorRequest, opts ...grpc.CallOption) (*gitalypb.CommitIsAncestorResponse, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "CommitIsAncestor", varargs...)
	ret0, _ := ret[0].(*gitalypb.CommitIsAncestorResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CommitIsAncestor indicates an expected call of CommitIsAncestor.
func (mr *MockCommitServiceClientMockRecorder) CommitIsAncestor(ctx, in any, opts ...any) *MockCommitServiceClientCommitIsAncestorCall {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, in}, opts...)
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CommitIsAncestor", reflect.TypeOf((*MockCommitServiceClient)(nil).CommitIsAncestor), varargs...)
	return &MockCommitServiceClientCommitIsAncestorCall{Call: call}
}

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

// Return rewrite *gomock.Call.Return
func (c *MockCommitServiceClientCommitIsAncestorCall) Return(arg0 *gitalypb.CommitIsAncestorResponse, arg1 error) *MockCommitServiceClientCommitIsAncestorCall {
	c.Call = c.Call.Return(arg0, arg1)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockCommitServiceClientCommitIsAncestorCall) Do(f func(context.Context, *gitalypb.CommitIsAncestorRequest, ...grpc.CallOption) (*gitalypb.CommitIsAncestorResponse, error)) *MockCommitServiceClientCommitIsAncestorCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockCommitServiceClientCommitIsAncestorCall) DoAndReturn(f func(context.Context, *gitalypb.CommitIsAncestorRequest, ...grpc.CallOption) (*gitalypb.CommitIsAncestorResponse, error)) *MockCommitServiceClientCommitIsAncestorCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// CommitLanguages mocks base method.
func (m *MockCommitServiceClient) CommitLanguages(ctx context.Context, in *gitalypb.CommitLanguagesRequest, opts ...grpc.CallOption) (*gitalypb.CommitLanguagesResponse, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "CommitLanguages", varargs...)
	ret0, _ := ret[0].(*gitalypb.CommitLanguagesResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CommitLanguages indicates an expected call of CommitLanguages.
func (mr *MockCommitServiceClientMockRecorder) CommitLanguages(ctx, in any, opts ...any) *MockCommitServiceClientCommitLanguagesCall {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, in}, opts...)
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CommitLanguages", reflect.TypeOf((*MockCommitServiceClient)(nil).CommitLanguages), varargs...)
	return &MockCommitServiceClientCommitLanguagesCall{Call: call}
}

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

// Return rewrite *gomock.Call.Return
func (c *MockCommitServiceClientCommitLanguagesCall) Return(arg0 *gitalypb.CommitLanguagesResponse, arg1 error) *MockCommitServiceClientCommitLanguagesCall {
	c.Call = c.Call.Return(arg0, arg1)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockCommitServiceClientCommitLanguagesCall) Do(f func(context.Context, *gitalypb.CommitLanguagesRequest, ...grpc.CallOption) (*gitalypb.CommitLanguagesResponse, error)) *MockCommitServiceClientCommitLanguagesCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockCommitServiceClientCommitLanguagesCall) DoAndReturn(f func(context.Context, *gitalypb.CommitLanguagesRequest, ...grpc.CallOption) (*gitalypb.CommitLanguagesResponse, error)) *MockCommitServiceClientCommitLanguagesCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// CommitStats mocks base method.
func (m *MockCommitServiceClient) CommitStats(ctx context.Context, in *gitalypb.CommitStatsRequest, opts ...grpc.CallOption) (*gitalypb.CommitStatsResponse, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "CommitStats", varargs...)
	ret0, _ := ret[0].(*gitalypb.CommitStatsResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CommitStats indicates an expected call of CommitStats.
func (mr *MockCommitServiceClientMockRecorder) CommitStats(ctx, in any, opts ...any) *MockCommitServiceClientCommitStatsCall {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, in}, opts...)
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CommitStats", reflect.TypeOf((*MockCommitServiceClient)(nil).CommitStats), varargs...)
	return &MockCommitServiceClientCommitStatsCall{Call: call}
}

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

// Return rewrite *gomock.Call.Return
func (c *MockCommitServiceClientCommitStatsCall) Return(arg0 *gitalypb.CommitStatsResponse, arg1 error) *MockCommitServiceClientCommitStatsCall {
	c.Call = c.Call.Return(arg0, arg1)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockCommitServiceClientCommitStatsCall) Do(f func(context.Context, *gitalypb.CommitStatsRequest, ...grpc.CallOption) (*gitalypb.CommitStatsResponse, error)) *MockCommitServiceClientCommitStatsCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockCommitServiceClientCommitStatsCall) DoAndReturn(f func(context.Context, *gitalypb.CommitStatsRequest, ...grpc.CallOption) (*gitalypb.CommitStatsResponse, error)) *MockCommitServiceClientCommitStatsCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// CommitsByMessage mocks base method.
func (m *MockCommitServiceClient) CommitsByMessage(ctx context.Context, in *gitalypb.CommitsByMessageRequest, opts ...grpc.CallOption) (grpc.ServerStreamingClient[gitalypb.CommitsByMessageResponse], error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "CommitsByMessage", varargs...)
	ret0, _ := ret[0].(grpc.ServerStreamingClient[gitalypb.CommitsByMessageResponse])
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CommitsByMessage indicates an expected call of CommitsByMessage.
func (mr *MockCommitServiceClientMockRecorder) CommitsByMessage(ctx, in any, opts ...any) *MockCommitServiceClientCommitsByMessageCall {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, in}, opts...)
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CommitsByMessage", reflect.TypeOf((*MockCommitServiceClient)(nil).CommitsByMessage), varargs...)
	return &MockCommitServiceClientCommitsByMessageCall{Call: call}
}

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

// Return rewrite *gomock.Call.Return
func (c *MockCommitServiceClientCommitsByMessageCall) Return(arg0 grpc.ServerStreamingClient[gitalypb.CommitsByMessageResponse], arg1 error) *MockCommitServiceClientCommitsByMessageCall {
	c.Call = c.Call.Return(arg0, arg1)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockCommitServiceClientCommitsByMessageCall) Do(f func(context.Context, *gitalypb.CommitsByMessageRequest, ...grpc.CallOption) (grpc.ServerStreamingClient[gitalypb.CommitsByMessageResponse], error)) *MockCommitServiceClientCommitsByMessageCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockCommitServiceClientCommitsByMessageCall) DoAndReturn(f func(context.Context, *gitalypb.CommitsByMessageRequest, ...grpc.CallOption) (grpc.ServerStreamingClient[gitalypb.CommitsByMessageResponse], error)) *MockCommitServiceClientCommitsByMessageCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// CountCommits mocks base method.
func (m *MockCommitServiceClient) CountCommits(ctx context.Context, in *gitalypb.CountCommitsRequest, opts ...grpc.CallOption) (*gitalypb.CountCommitsResponse, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "CountCommits", varargs...)
	ret0, _ := ret[0].(*gitalypb.CountCommitsResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CountCommits indicates an expected call of CountCommits.
func (mr *MockCommitServiceClientMockRecorder) CountCommits(ctx, in any, opts ...any) *MockCommitServiceClientCountCommitsCall {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, in}, opts...)
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CountCommits", reflect.TypeOf((*MockCommitServiceClient)(nil).CountCommits), varargs...)
	return &MockCommitServiceClientCountCommitsCall{Call: call}
}

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

// Return rewrite *gomock.Call.Return
func (c *MockCommitServiceClientCountCommitsCall) Return(arg0 *gitalypb.CountCommitsResponse, arg1 error) *MockCommitServiceClientCountCommitsCall {
	c.Call = c.Call.Return(arg0, arg1)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockCommitServiceClientCountCommitsCall) Do(f func(context.Context, *gitalypb.CountCommitsRequest, ...grpc.CallOption) (*gitalypb.CountCommitsResponse, error)) *MockCommitServiceClientCountCommitsCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockCommitServiceClientCountCommitsCall) DoAndReturn(f func(context.Context, *gitalypb.CountCommitsRequest, ...grpc.CallOption) (*gitalypb.CountCommitsResponse, error)) *MockCommitServiceClientCountCommitsCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// CountDivergingCommits mocks base method.
func (m *MockCommitServiceClient) CountDivergingCommits(ctx context.Context, in *gitalypb.CountDivergingCommitsRequest, opts ...grpc.CallOption) (*gitalypb.CountDivergingCommitsResponse, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "CountDivergingCommits", varargs...)
	ret0, _ := ret[0].(*gitalypb.CountDivergingCommitsResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CountDivergingCommits indicates an expected call of CountDivergingCommits.
func (mr *MockCommitServiceClientMockRecorder) CountDivergingCommits(ctx, in any, opts ...any) *MockCommitServiceClientCountDivergingCommitsCall {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, in}, opts...)
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CountDivergingCommits", reflect.TypeOf((*MockCommitServiceClient)(nil).CountDivergingCommits), varargs...)
	return &MockCommitServiceClientCountDivergingCommitsCall{Call: call}
}

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

// Return rewrite *gomock.Call.Return
func (c *MockCommitServiceClientCountDivergingCommitsCall) Return(arg0 *gitalypb.CountDivergingCommitsResponse, arg1 error) *MockCommitServiceClientCountDivergingCommitsCall {
	c.Call = c.Call.Return(arg0, arg1)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockCommitServiceClientCountDivergingCommitsCall) Do(f func(context.Context, *gitalypb.CountDivergingCommitsRequest, ...grpc.CallOption) (*gitalypb.CountDivergingCommitsResponse, error)) *MockCommitServiceClientCountDivergingCommitsCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockCommitServiceClientCountDivergingCommitsCall) DoAndReturn(f func(context.Context, *gitalypb.CountDivergingCommitsRequest, ...grpc.CallOption) (*gitalypb.CountDivergingCommitsResponse, error)) *MockCommitServiceClientCountDivergingCommitsCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// FilterShasWithSignatures mocks base method.
func (m *MockCommitServiceClient) FilterShasWithSignatures(ctx context.Context, opts ...grpc.CallOption) (grpc.BidiStreamingClient[gitalypb.FilterShasWithSignaturesRequest, gitalypb.FilterShasWithSignaturesResponse], error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "FilterShasWithSignatures", varargs...)
	ret0, _ := ret[0].(grpc.BidiStreamingClient[gitalypb.FilterShasWithSignaturesRequest, gitalypb.FilterShasWithSignaturesResponse])
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// FilterShasWithSignatures indicates an expected call of FilterShasWithSignatures.
func (mr *MockCommitServiceClientMockRecorder) FilterShasWithSignatures(ctx any, opts ...any) *MockCommitServiceClientFilterShasWithSignaturesCall {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx}, opts...)
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FilterShasWithSignatures", reflect.TypeOf((*MockCommitServiceClient)(nil).FilterShasWithSignatures), varargs...)
	return &MockCommitServiceClientFilterShasWithSignaturesCall{Call: call}
}

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

// Return rewrite *gomock.Call.Return
func (c *MockCommitServiceClientFilterShasWithSignaturesCall) Return(arg0 grpc.BidiStreamingClient[gitalypb.FilterShasWithSignaturesRequest, gitalypb.FilterShasWithSignaturesResponse], arg1 error) *MockCommitServiceClientFilterShasWithSignaturesCall {
	c.Call = c.Call.Return(arg0, arg1)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockCommitServiceClientFilterShasWithSignaturesCall) Do(f func(context.Context, ...grpc.CallOption) (grpc.BidiStreamingClient[gitalypb.FilterShasWithSignaturesRequest, gitalypb.FilterShasWithSignaturesResponse], error)) *MockCommitServiceClientFilterShasWithSignaturesCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockCommitServiceClientFilterShasWithSignaturesCall) DoAndReturn(f func(context.Context, ...grpc.CallOption) (grpc.BidiStreamingClient[gitalypb.FilterShasWithSignaturesRequest, gitalypb.FilterShasWithSignaturesResponse], error)) *MockCommitServiceClientFilterShasWithSignaturesCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// FindAllCommits mocks base method.
func (m *MockCommitServiceClient) FindAllCommits(ctx context.Context, in *gitalypb.FindAllCommitsRequest, opts ...grpc.CallOption) (grpc.ServerStreamingClient[gitalypb.FindAllCommitsResponse], error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "FindAllCommits", varargs...)
	ret0, _ := ret[0].(grpc.ServerStreamingClient[gitalypb.FindAllCommitsResponse])
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// FindAllCommits indicates an expected call of FindAllCommits.
func (mr *MockCommitServiceClientMockRecorder) FindAllCommits(ctx, in any, opts ...any) *MockCommitServiceClientFindAllCommitsCall {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, in}, opts...)
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FindAllCommits", reflect.TypeOf((*MockCommitServiceClient)(nil).FindAllCommits), varargs...)
	return &MockCommitServiceClientFindAllCommitsCall{Call: call}
}

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

// Return rewrite *gomock.Call.Return
func (c *MockCommitServiceClientFindAllCommitsCall) Return(arg0 grpc.ServerStreamingClient[gitalypb.FindAllCommitsResponse], arg1 error) *MockCommitServiceClientFindAllCommitsCall {
	c.Call = c.Call.Return(arg0, arg1)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockCommitServiceClientFindAllCommitsCall) Do(f func(context.Context, *gitalypb.FindAllCommitsRequest, ...grpc.CallOption) (grpc.ServerStreamingClient[gitalypb.FindAllCommitsResponse], error)) *MockCommitServiceClientFindAllCommitsCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockCommitServiceClientFindAllCommitsCall) DoAndReturn(f func(context.Context, *gitalypb.FindAllCommitsRequest, ...grpc.CallOption) (grpc.ServerStreamingClient[gitalypb.FindAllCommitsResponse], error)) *MockCommitServiceClientFindAllCommitsCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// FindCommit mocks base method.
func (m *MockCommitServiceClient) FindCommit(ctx context.Context, in *gitalypb.FindCommitRequest, opts ...grpc.CallOption) (*gitalypb.FindCommitResponse, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "FindCommit", varargs...)
	ret0, _ := ret[0].(*gitalypb.FindCommitResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// FindCommit indicates an expected call of FindCommit.
func (mr *MockCommitServiceClientMockRecorder) FindCommit(ctx, in any, opts ...any) *MockCommitServiceClientFindCommitCall {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, in}, opts...)
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FindCommit", reflect.TypeOf((*MockCommitServiceClient)(nil).FindCommit), varargs...)
	return &MockCommitServiceClientFindCommitCall{Call: call}
}

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

// Return rewrite *gomock.Call.Return
func (c *MockCommitServiceClientFindCommitCall) Return(arg0 *gitalypb.FindCommitResponse, arg1 error) *MockCommitServiceClientFindCommitCall {
	c.Call = c.Call.Return(arg0, arg1)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockCommitServiceClientFindCommitCall) Do(f func(context.Context, *gitalypb.FindCommitRequest, ...grpc.CallOption) (*gitalypb.FindCommitResponse, error)) *MockCommitServiceClientFindCommitCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockCommitServiceClientFindCommitCall) DoAndReturn(f func(context.Context, *gitalypb.FindCommitRequest, ...grpc.CallOption) (*gitalypb.FindCommitResponse, error)) *MockCommitServiceClientFindCommitCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// FindCommits mocks base method.
func (m *MockCommitServiceClient) FindCommits(ctx context.Context, in *gitalypb.FindCommitsRequest, opts ...grpc.CallOption) (grpc.ServerStreamingClient[gitalypb.FindCommitsResponse], error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "FindCommits", varargs...)
	ret0, _ := ret[0].(grpc.ServerStreamingClient[gitalypb.FindCommitsResponse])
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// FindCommits indicates an expected call of FindCommits.
func (mr *MockCommitServiceClientMockRecorder) FindCommits(ctx, in any, opts ...any) *MockCommitServiceClientFindCommitsCall {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, in}, opts...)
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FindCommits", reflect.TypeOf((*MockCommitServiceClient)(nil).FindCommits), varargs...)
	return &MockCommitServiceClientFindCommitsCall{Call: call}
}

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

// Return rewrite *gomock.Call.Return
func (c *MockCommitServiceClientFindCommitsCall) Return(arg0 grpc.ServerStreamingClient[gitalypb.FindCommitsResponse], arg1 error) *MockCommitServiceClientFindCommitsCall {
	c.Call = c.Call.Return(arg0, arg1)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockCommitServiceClientFindCommitsCall) Do(f func(context.Context, *gitalypb.FindCommitsRequest, ...grpc.CallOption) (grpc.ServerStreamingClient[gitalypb.FindCommitsResponse], error)) *MockCommitServiceClientFindCommitsCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockCommitServiceClientFindCommitsCall) DoAndReturn(f func(context.Context, *gitalypb.FindCommitsRequest, ...grpc.CallOption) (grpc.ServerStreamingClient[gitalypb.FindCommitsResponse], error)) *MockCommitServiceClientFindCommitsCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// GetCommitMessages mocks base method.
func (m *MockCommitServiceClient) GetCommitMessages(ctx context.Context, in *gitalypb.GetCommitMessagesRequest, opts ...grpc.CallOption) (grpc.ServerStreamingClient[gitalypb.GetCommitMessagesResponse], error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetCommitMessages", varargs...)
	ret0, _ := ret[0].(grpc.ServerStreamingClient[gitalypb.GetCommitMessagesResponse])
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetCommitMessages indicates an expected call of GetCommitMessages.
func (mr *MockCommitServiceClientMockRecorder) GetCommitMessages(ctx, in any, opts ...any) *MockCommitServiceClientGetCommitMessagesCall {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, in}, opts...)
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetCommitMessages", reflect.TypeOf((*MockCommitServiceClient)(nil).GetCommitMessages), varargs...)
	return &MockCommitServiceClientGetCommitMessagesCall{Call: call}
}

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

// Return rewrite *gomock.Call.Return
func (c *MockCommitServiceClientGetCommitMessagesCall) Return(arg0 grpc.ServerStreamingClient[gitalypb.GetCommitMessagesResponse], arg1 error) *MockCommitServiceClientGetCommitMessagesCall {
	c.Call = c.Call.Return(arg0, arg1)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockCommitServiceClientGetCommitMessagesCall) Do(f func(context.Context, *gitalypb.GetCommitMessagesRequest, ...grpc.CallOption) (grpc.ServerStreamingClient[gitalypb.GetCommitMessagesResponse], error)) *MockCommitServiceClientGetCommitMessagesCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockCommitServiceClientGetCommitMessagesCall) DoAndReturn(f func(context.Context, *gitalypb.GetCommitMessagesRequest, ...grpc.CallOption) (grpc.ServerStreamingClient[gitalypb.GetCommitMessagesResponse], error)) *MockCommitServiceClientGetCommitMessagesCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// GetCommitSignatures mocks base method.
func (m *MockCommitServiceClient) GetCommitSignatures(ctx context.Context, in *gitalypb.GetCommitSignaturesRequest, opts ...grpc.CallOption) (grpc.ServerStreamingClient[gitalypb.GetCommitSignaturesResponse], error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetCommitSignatures", varargs...)
	ret0, _ := ret[0].(grpc.ServerStreamingClient[gitalypb.GetCommitSignaturesResponse])
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetCommitSignatures indicates an expected call of GetCommitSignatures.
func (mr *MockCommitServiceClientMockRecorder) GetCommitSignatures(ctx, in any, opts ...any) *MockCommitServiceClientGetCommitSignaturesCall {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, in}, opts...)
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetCommitSignatures", reflect.TypeOf((*MockCommitServiceClient)(nil).GetCommitSignatures), varargs...)
	return &MockCommitServiceClientGetCommitSignaturesCall{Call: call}
}

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

// Return rewrite *gomock.Call.Return
func (c *MockCommitServiceClientGetCommitSignaturesCall) Return(arg0 grpc.ServerStreamingClient[gitalypb.GetCommitSignaturesResponse], arg1 error) *MockCommitServiceClientGetCommitSignaturesCall {
	c.Call = c.Call.Return(arg0, arg1)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockCommitServiceClientGetCommitSignaturesCall) Do(f func(context.Context, *gitalypb.GetCommitSignaturesRequest, ...grpc.CallOption) (grpc.ServerStreamingClient[gitalypb.GetCommitSignaturesResponse], error)) *MockCommitServiceClientGetCommitSignaturesCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockCommitServiceClientGetCommitSignaturesCall) DoAndReturn(f func(context.Context, *gitalypb.GetCommitSignaturesRequest, ...grpc.CallOption) (grpc.ServerStreamingClient[gitalypb.GetCommitSignaturesResponse], error)) *MockCommitServiceClientGetCommitSignaturesCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// GetTreeEntries mocks base method.
func (m *MockCommitServiceClient) GetTreeEntries(ctx context.Context, in *gitalypb.GetTreeEntriesRequest, opts ...grpc.CallOption) (grpc.ServerStreamingClient[gitalypb.GetTreeEntriesResponse], error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetTreeEntries", varargs...)
	ret0, _ := ret[0].(grpc.ServerStreamingClient[gitalypb.GetTreeEntriesResponse])
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetTreeEntries indicates an expected call of GetTreeEntries.
func (mr *MockCommitServiceClientMockRecorder) GetTreeEntries(ctx, in any, opts ...any) *MockCommitServiceClientGetTreeEntriesCall {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, in}, opts...)
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTreeEntries", reflect.TypeOf((*MockCommitServiceClient)(nil).GetTreeEntries), varargs...)
	return &MockCommitServiceClientGetTreeEntriesCall{Call: call}
}

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

// Return rewrite *gomock.Call.Return
func (c *MockCommitServiceClientGetTreeEntriesCall) Return(arg0 grpc.ServerStreamingClient[gitalypb.GetTreeEntriesResponse], arg1 error) *MockCommitServiceClientGetTreeEntriesCall {
	c.Call = c.Call.Return(arg0, arg1)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockCommitServiceClientGetTreeEntriesCall) Do(f func(context.Context, *gitalypb.GetTreeEntriesRequest, ...grpc.CallOption) (grpc.ServerStreamingClient[gitalypb.GetTreeEntriesResponse], error)) *MockCommitServiceClientGetTreeEntriesCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockCommitServiceClientGetTreeEntriesCall) DoAndReturn(f func(context.Context, *gitalypb.GetTreeEntriesRequest, ...grpc.CallOption) (grpc.ServerStreamingClient[gitalypb.GetTreeEntriesResponse], error)) *MockCommitServiceClientGetTreeEntriesCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// LastCommitForPath mocks base method.
func (m *MockCommitServiceClient) LastCommitForPath(ctx context.Context, in *gitalypb.LastCommitForPathRequest, opts ...grpc.CallOption) (*gitalypb.LastCommitForPathResponse, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "LastCommitForPath", varargs...)
	ret0, _ := ret[0].(*gitalypb.LastCommitForPathResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// LastCommitForPath indicates an expected call of LastCommitForPath.
func (mr *MockCommitServiceClientMockRecorder) LastCommitForPath(ctx, in any, opts ...any) *MockCommitServiceClientLastCommitForPathCall {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, in}, opts...)
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LastCommitForPath", reflect.TypeOf((*MockCommitServiceClient)(nil).LastCommitForPath), varargs...)
	return &MockCommitServiceClientLastCommitForPathCall{Call: call}
}

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

// Return rewrite *gomock.Call.Return
func (c *MockCommitServiceClientLastCommitForPathCall) Return(arg0 *gitalypb.LastCommitForPathResponse, arg1 error) *MockCommitServiceClientLastCommitForPathCall {
	c.Call = c.Call.Return(arg0, arg1)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockCommitServiceClientLastCommitForPathCall) Do(f func(context.Context, *gitalypb.LastCommitForPathRequest, ...grpc.CallOption) (*gitalypb.LastCommitForPathResponse, error)) *MockCommitServiceClientLastCommitForPathCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockCommitServiceClientLastCommitForPathCall) DoAndReturn(f func(context.Context, *gitalypb.LastCommitForPathRequest, ...grpc.CallOption) (*gitalypb.LastCommitForPathResponse, error)) *MockCommitServiceClientLastCommitForPathCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// ListAllCommits mocks base method.
func (m *MockCommitServiceClient) ListAllCommits(ctx context.Context, in *gitalypb.ListAllCommitsRequest, opts ...grpc.CallOption) (grpc.ServerStreamingClient[gitalypb.ListAllCommitsResponse], error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListAllCommits", varargs...)
	ret0, _ := ret[0].(grpc.ServerStreamingClient[gitalypb.ListAllCommitsResponse])
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListAllCommits indicates an expected call of ListAllCommits.
func (mr *MockCommitServiceClientMockRecorder) ListAllCommits(ctx, in any, opts ...any) *MockCommitServiceClientListAllCommitsCall {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, in}, opts...)
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListAllCommits", reflect.TypeOf((*MockCommitServiceClient)(nil).ListAllCommits), varargs...)
	return &MockCommitServiceClientListAllCommitsCall{Call: call}
}

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

// Return rewrite *gomock.Call.Return
func (c *MockCommitServiceClientListAllCommitsCall) Return(arg0 grpc.ServerStreamingClient[gitalypb.ListAllCommitsResponse], arg1 error) *MockCommitServiceClientListAllCommitsCall {
	c.Call = c.Call.Return(arg0, arg1)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockCommitServiceClientListAllCommitsCall) Do(f func(context.Context, *gitalypb.ListAllCommitsRequest, ...grpc.CallOption) (grpc.ServerStreamingClient[gitalypb.ListAllCommitsResponse], error)) *MockCommitServiceClientListAllCommitsCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockCommitServiceClientListAllCommitsCall) DoAndReturn(f func(context.Context, *gitalypb.ListAllCommitsRequest, ...grpc.CallOption) (grpc.ServerStreamingClient[gitalypb.ListAllCommitsResponse], error)) *MockCommitServiceClientListAllCommitsCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// ListCommits mocks base method.
func (m *MockCommitServiceClient) ListCommits(ctx context.Context, in *gitalypb.ListCommitsRequest, opts ...grpc.CallOption) (grpc.ServerStreamingClient[gitalypb.ListCommitsResponse], error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListCommits", varargs...)
	ret0, _ := ret[0].(grpc.ServerStreamingClient[gitalypb.ListCommitsResponse])
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListCommits indicates an expected call of ListCommits.
func (mr *MockCommitServiceClientMockRecorder) ListCommits(ctx, in any, opts ...any) *MockCommitServiceClientListCommitsCall {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, in}, opts...)
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListCommits", reflect.TypeOf((*MockCommitServiceClient)(nil).ListCommits), varargs...)
	return &MockCommitServiceClientListCommitsCall{Call: call}
}

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

// Return rewrite *gomock.Call.Return
func (c *MockCommitServiceClientListCommitsCall) Return(arg0 grpc.ServerStreamingClient[gitalypb.ListCommitsResponse], arg1 error) *MockCommitServiceClientListCommitsCall {
	c.Call = c.Call.Return(arg0, arg1)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockCommitServiceClientListCommitsCall) Do(f func(context.Context, *gitalypb.ListCommitsRequest, ...grpc.CallOption) (grpc.ServerStreamingClient[gitalypb.ListCommitsResponse], error)) *MockCommitServiceClientListCommitsCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockCommitServiceClientListCommitsCall) DoAndReturn(f func(context.Context, *gitalypb.ListCommitsRequest, ...grpc.CallOption) (grpc.ServerStreamingClient[gitalypb.ListCommitsResponse], error)) *MockCommitServiceClientListCommitsCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// ListCommitsByOid mocks base method.
func (m *MockCommitServiceClient) ListCommitsByOid(ctx context.Context, in *gitalypb.ListCommitsByOidRequest, opts ...grpc.CallOption) (grpc.ServerStreamingClient[gitalypb.ListCommitsByOidResponse], error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListCommitsByOid", varargs...)
	ret0, _ := ret[0].(grpc.ServerStreamingClient[gitalypb.ListCommitsByOidResponse])
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListCommitsByOid indicates an expected call of ListCommitsByOid.
func (mr *MockCommitServiceClientMockRecorder) ListCommitsByOid(ctx, in any, opts ...any) *MockCommitServiceClientListCommitsByOidCall {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, in}, opts...)
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListCommitsByOid", reflect.TypeOf((*MockCommitServiceClient)(nil).ListCommitsByOid), varargs...)
	return &MockCommitServiceClientListCommitsByOidCall{Call: call}
}

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

// Return rewrite *gomock.Call.Return
func (c *MockCommitServiceClientListCommitsByOidCall) Return(arg0 grpc.ServerStreamingClient[gitalypb.ListCommitsByOidResponse], arg1 error) *MockCommitServiceClientListCommitsByOidCall {
	c.Call = c.Call.Return(arg0, arg1)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockCommitServiceClientListCommitsByOidCall) Do(f func(context.Context, *gitalypb.ListCommitsByOidRequest, ...grpc.CallOption) (grpc.ServerStreamingClient[gitalypb.ListCommitsByOidResponse], error)) *MockCommitServiceClientListCommitsByOidCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockCommitServiceClientListCommitsByOidCall) DoAndReturn(f func(context.Context, *gitalypb.ListCommitsByOidRequest, ...grpc.CallOption) (grpc.ServerStreamingClient[gitalypb.ListCommitsByOidResponse], error)) *MockCommitServiceClientListCommitsByOidCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// ListCommitsByRefName mocks base method.
func (m *MockCommitServiceClient) ListCommitsByRefName(ctx context.Context, in *gitalypb.ListCommitsByRefNameRequest, opts ...grpc.CallOption) (grpc.ServerStreamingClient[gitalypb.ListCommitsByRefNameResponse], error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListCommitsByRefName", varargs...)
	ret0, _ := ret[0].(grpc.ServerStreamingClient[gitalypb.ListCommitsByRefNameResponse])
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListCommitsByRefName indicates an expected call of ListCommitsByRefName.
func (mr *MockCommitServiceClientMockRecorder) ListCommitsByRefName(ctx, in any, opts ...any) *MockCommitServiceClientListCommitsByRefNameCall {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, in}, opts...)
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListCommitsByRefName", reflect.TypeOf((*MockCommitServiceClient)(nil).ListCommitsByRefName), varargs...)
	return &MockCommitServiceClientListCommitsByRefNameCall{Call: call}
}

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

// Return rewrite *gomock.Call.Return
func (c *MockCommitServiceClientListCommitsByRefNameCall) Return(arg0 grpc.ServerStreamingClient[gitalypb.ListCommitsByRefNameResponse], arg1 error) *MockCommitServiceClientListCommitsByRefNameCall {
	c.Call = c.Call.Return(arg0, arg1)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockCommitServiceClientListCommitsByRefNameCall) Do(f func(context.Context, *gitalypb.ListCommitsByRefNameRequest, ...grpc.CallOption) (grpc.ServerStreamingClient[gitalypb.ListCommitsByRefNameResponse], error)) *MockCommitServiceClientListCommitsByRefNameCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockCommitServiceClientListCommitsByRefNameCall) DoAndReturn(f func(context.Context, *gitalypb.ListCommitsByRefNameRequest, ...grpc.CallOption) (grpc.ServerStreamingClient[gitalypb.ListCommitsByRefNameResponse], error)) *MockCommitServiceClientListCommitsByRefNameCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// ListFiles mocks base method.
func (m *MockCommitServiceClient) ListFiles(ctx context.Context, in *gitalypb.ListFilesRequest, opts ...grpc.CallOption) (grpc.ServerStreamingClient[gitalypb.ListFilesResponse], error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListFiles", varargs...)
	ret0, _ := ret[0].(grpc.ServerStreamingClient[gitalypb.ListFilesResponse])
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListFiles indicates an expected call of ListFiles.
func (mr *MockCommitServiceClientMockRecorder) ListFiles(ctx, in any, opts ...any) *MockCommitServiceClientListFilesCall {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, in}, opts...)
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListFiles", reflect.TypeOf((*MockCommitServiceClient)(nil).ListFiles), varargs...)
	return &MockCommitServiceClientListFilesCall{Call: call}
}

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

// Return rewrite *gomock.Call.Return
func (c *MockCommitServiceClientListFilesCall) Return(arg0 grpc.ServerStreamingClient[gitalypb.ListFilesResponse], arg1 error) *MockCommitServiceClientListFilesCall {
	c.Call = c.Call.Return(arg0, arg1)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockCommitServiceClientListFilesCall) Do(f func(context.Context, *gitalypb.ListFilesRequest, ...grpc.CallOption) (grpc.ServerStreamingClient[gitalypb.ListFilesResponse], error)) *MockCommitServiceClientListFilesCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockCommitServiceClientListFilesCall) DoAndReturn(f func(context.Context, *gitalypb.ListFilesRequest, ...grpc.CallOption) (grpc.ServerStreamingClient[gitalypb.ListFilesResponse], error)) *MockCommitServiceClientListFilesCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// ListLastCommitsForTree mocks base method.
func (m *MockCommitServiceClient) ListLastCommitsForTree(ctx context.Context, in *gitalypb.ListLastCommitsForTreeRequest, opts ...grpc.CallOption) (grpc.ServerStreamingClient[gitalypb.ListLastCommitsForTreeResponse], error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListLastCommitsForTree", varargs...)
	ret0, _ := ret[0].(grpc.ServerStreamingClient[gitalypb.ListLastCommitsForTreeResponse])
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListLastCommitsForTree indicates an expected call of ListLastCommitsForTree.
func (mr *MockCommitServiceClientMockRecorder) ListLastCommitsForTree(ctx, in any, opts ...any) *MockCommitServiceClientListLastCommitsForTreeCall {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, in}, opts...)
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListLastCommitsForTree", reflect.TypeOf((*MockCommitServiceClient)(nil).ListLastCommitsForTree), varargs...)
	return &MockCommitServiceClientListLastCommitsForTreeCall{Call: call}
}

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

// Return rewrite *gomock.Call.Return
func (c *MockCommitServiceClientListLastCommitsForTreeCall) Return(arg0 grpc.ServerStreamingClient[gitalypb.ListLastCommitsForTreeResponse], arg1 error) *MockCommitServiceClientListLastCommitsForTreeCall {
	c.Call = c.Call.Return(arg0, arg1)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockCommitServiceClientListLastCommitsForTreeCall) Do(f func(context.Context, *gitalypb.ListLastCommitsForTreeRequest, ...grpc.CallOption) (grpc.ServerStreamingClient[gitalypb.ListLastCommitsForTreeResponse], error)) *MockCommitServiceClientListLastCommitsForTreeCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockCommitServiceClientListLastCommitsForTreeCall) DoAndReturn(f func(context.Context, *gitalypb.ListLastCommitsForTreeRequest, ...grpc.CallOption) (grpc.ServerStreamingClient[gitalypb.ListLastCommitsForTreeResponse], error)) *MockCommitServiceClientListLastCommitsForTreeCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// RawBlame mocks base method.
func (m *MockCommitServiceClient) RawBlame(ctx context.Context, in *gitalypb.RawBlameRequest, opts ...grpc.CallOption) (grpc.ServerStreamingClient[gitalypb.RawBlameResponse], error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "RawBlame", varargs...)
	ret0, _ := ret[0].(grpc.ServerStreamingClient[gitalypb.RawBlameResponse])
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// RawBlame indicates an expected call of RawBlame.
func (mr *MockCommitServiceClientMockRecorder) RawBlame(ctx, in any, opts ...any) *MockCommitServiceClientRawBlameCall {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, in}, opts...)
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RawBlame", reflect.TypeOf((*MockCommitServiceClient)(nil).RawBlame), varargs...)
	return &MockCommitServiceClientRawBlameCall{Call: call}
}

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

// Return rewrite *gomock.Call.Return
func (c *MockCommitServiceClientRawBlameCall) Return(arg0 grpc.ServerStreamingClient[gitalypb.RawBlameResponse], arg1 error) *MockCommitServiceClientRawBlameCall {
	c.Call = c.Call.Return(arg0, arg1)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockCommitServiceClientRawBlameCall) Do(f func(context.Context, *gitalypb.RawBlameRequest, ...grpc.CallOption) (grpc.ServerStreamingClient[gitalypb.RawBlameResponse], error)) *MockCommitServiceClientRawBlameCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockCommitServiceClientRawBlameCall) DoAndReturn(f func(context.Context, *gitalypb.RawBlameRequest, ...grpc.CallOption) (grpc.ServerStreamingClient[gitalypb.RawBlameResponse], error)) *MockCommitServiceClientRawBlameCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// TreeEntry mocks base method.
func (m *MockCommitServiceClient) TreeEntry(ctx context.Context, in *gitalypb.TreeEntryRequest, opts ...grpc.CallOption) (grpc.ServerStreamingClient[gitalypb.TreeEntryResponse], error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "TreeEntry", varargs...)
	ret0, _ := ret[0].(grpc.ServerStreamingClient[gitalypb.TreeEntryResponse])
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// TreeEntry indicates an expected call of TreeEntry.
func (mr *MockCommitServiceClientMockRecorder) TreeEntry(ctx, in any, opts ...any) *MockCommitServiceClientTreeEntryCall {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, in}, opts...)
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TreeEntry", reflect.TypeOf((*MockCommitServiceClient)(nil).TreeEntry), varargs...)
	return &MockCommitServiceClientTreeEntryCall{Call: call}
}

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

// Return rewrite *gomock.Call.Return
func (c *MockCommitServiceClientTreeEntryCall) Return(arg0 grpc.ServerStreamingClient[gitalypb.TreeEntryResponse], arg1 error) *MockCommitServiceClientTreeEntryCall {
	c.Call = c.Call.Return(arg0, arg1)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockCommitServiceClientTreeEntryCall) Do(f func(context.Context, *gitalypb.TreeEntryRequest, ...grpc.CallOption) (grpc.ServerStreamingClient[gitalypb.TreeEntryResponse], error)) *MockCommitServiceClientTreeEntryCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockCommitServiceClientTreeEntryCall) DoAndReturn(f func(context.Context, *gitalypb.TreeEntryRequest, ...grpc.CallOption) (grpc.ServerStreamingClient[gitalypb.TreeEntryResponse], error)) *MockCommitServiceClientTreeEntryCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// MockCommitServiceServer is a mock of CommitServiceServer interface.
type MockCommitServiceServer struct {
	ctrl     *gomock.Controller
	recorder *MockCommitServiceServerMockRecorder
	isgomock struct{}
}

// MockCommitServiceServerMockRecorder is the mock recorder for MockCommitServiceServer.
type MockCommitServiceServerMockRecorder struct {
	mock *MockCommitServiceServer
}

// NewMockCommitServiceServer creates a new mock instance.
func NewMockCommitServiceServer(ctrl *gomock.Controller) *MockCommitServiceServer {
	mock := &MockCommitServiceServer{ctrl: ctrl}
	mock.recorder = &MockCommitServiceServerMockRecorder{mock}
	return mock
}

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

// CheckObjectsExist mocks base method.
func (m *MockCommitServiceServer) CheckObjectsExist(arg0 grpc.BidiStreamingServer[gitalypb.CheckObjectsExistRequest, gitalypb.CheckObjectsExistResponse]) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CheckObjectsExist", arg0)
	ret0, _ := ret[0].(error)
	return ret0
}

// CheckObjectsExist indicates an expected call of CheckObjectsExist.
func (mr *MockCommitServiceServerMockRecorder) CheckObjectsExist(arg0 any) *MockCommitServiceServerCheckObjectsExistCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CheckObjectsExist", reflect.TypeOf((*MockCommitServiceServer)(nil).CheckObjectsExist), arg0)
	return &MockCommitServiceServerCheckObjectsExistCall{Call: call}
}

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

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

// Do rewrite *gomock.Call.Do
func (c *MockCommitServiceServerCheckObjectsExistCall) Do(f func(grpc.BidiStreamingServer[gitalypb.CheckObjectsExistRequest, gitalypb.CheckObjectsExistResponse]) error) *MockCommitServiceServerCheckObjectsExistCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockCommitServiceServerCheckObjectsExistCall) DoAndReturn(f func(grpc.BidiStreamingServer[gitalypb.CheckObjectsExistRequest, gitalypb.CheckObjectsExistResponse]) error) *MockCommitServiceServerCheckObjectsExistCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// CommitIsAncestor mocks base method.
func (m *MockCommitServiceServer) CommitIsAncestor(arg0 context.Context, arg1 *gitalypb.CommitIsAncestorRequest) (*gitalypb.CommitIsAncestorResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CommitIsAncestor", arg0, arg1)
	ret0, _ := ret[0].(*gitalypb.CommitIsAncestorResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

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

// Return rewrite *gomock.Call.Return
func (c *MockCommitServiceServerCommitIsAncestorCall) Return(arg0 *gitalypb.CommitIsAncestorResponse, arg1 error) *MockCommitServiceServerCommitIsAncestorCall {
	c.Call = c.Call.Return(arg0, arg1)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockCommitServiceServerCommitIsAncestorCall) Do(f func(context.Context, *gitalypb.CommitIsAncestorRequest) (*gitalypb.CommitIsAncestorResponse, error)) *MockCommitServiceServerCommitIsAncestorCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockCommitServiceServerCommitIsAncestorCall) DoAndReturn(f func(context.Context, *gitalypb.CommitIsAncestorRequest) (*gitalypb.CommitIsAncestorResponse, error)) *MockCommitServiceServerCommitIsAncestorCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// CommitLanguages mocks base method.
func (m *MockCommitServiceServer) CommitLanguages(arg0 context.Context, arg1 *gitalypb.CommitLanguagesRequest) (*gitalypb.CommitLanguagesResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CommitLanguages", arg0, arg1)
	ret0, _ := ret[0].(*gitalypb.CommitLanguagesResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

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

// Return rewrite *gomock.Call.Return
func (c *MockCommitServiceServerCommitLanguagesCall) Return(arg0 *gitalypb.CommitLanguagesResponse, arg1 error) *MockCommitServiceServerCommitLanguagesCall {
	c.Call = c.Call.Return(arg0, arg1)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockCommitServiceServerCommitLanguagesCall) Do(f func(context.Context, *gitalypb.CommitLanguagesRequest) (*gitalypb.CommitLanguagesResponse, error)) *MockCommitServiceServerCommitLanguagesCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockCommitServiceServerCommitLanguagesCall) DoAndReturn(f func(context.Context, *gitalypb.CommitLanguagesRequest) (*gitalypb.CommitLanguagesResponse, error)) *MockCommitServiceServerCommitLanguagesCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// CommitStats mocks base method.
func (m *MockCommitServiceServer) CommitStats(arg0 context.Context, arg1 *gitalypb.CommitStatsRequest) (*gitalypb.CommitStatsResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CommitStats", arg0, arg1)
	ret0, _ := ret[0].(*gitalypb.CommitStatsResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

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

// Return rewrite *gomock.Call.Return
func (c *MockCommitServiceServerCommitStatsCall) Return(arg0 *gitalypb.CommitStatsResponse, arg1 error) *MockCommitServiceServerCommitStatsCall {
	c.Call = c.Call.Return(arg0, arg1)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockCommitServiceServerCommitStatsCall) Do(f func(context.Context, *gitalypb.CommitStatsRequest) (*gitalypb.CommitStatsResponse, error)) *MockCommitServiceServerCommitStatsCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockCommitServiceServerCommitStatsCall) DoAndReturn(f func(context.Context, *gitalypb.CommitStatsRequest) (*gitalypb.CommitStatsResponse, error)) *MockCommitServiceServerCommitStatsCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// CommitsByMessage mocks base method.
func (m *MockCommitServiceServer) CommitsByMessage(arg0 *gitalypb.CommitsByMessageRequest, arg1 grpc.ServerStreamingServer[gitalypb.CommitsByMessageResponse]) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CommitsByMessage", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

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

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

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

// Do rewrite *gomock.Call.Do
func (c *MockCommitServiceServerCommitsByMessageCall) Do(f func(*gitalypb.CommitsByMessageRequest, grpc.ServerStreamingServer[gitalypb.CommitsByMessageResponse]) error) *MockCommitServiceServerCommitsByMessageCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockCommitServiceServerCommitsByMessageCall) DoAndReturn(f func(*gitalypb.CommitsByMessageRequest, grpc.ServerStreamingServer[gitalypb.CommitsByMessageResponse]) error) *MockCommitServiceServerCommitsByMessageCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// CountCommits mocks base method.
func (m *MockCommitServiceServer) CountCommits(arg0 context.Context, arg1 *gitalypb.CountCommitsRequest) (*gitalypb.CountCommitsResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CountCommits", arg0, arg1)
	ret0, _ := ret[0].(*gitalypb.CountCommitsResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

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

// Return rewrite *gomock.Call.Return
func (c *MockCommitServiceServerCountCommitsCall) Return(arg0 *gitalypb.CountCommitsResponse, arg1 error) *MockCommitServiceServerCountCommitsCall {
	c.Call = c.Call.Return(arg0, arg1)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockCommitServiceServerCountCommitsCall) Do(f func(context.Context, *gitalypb.CountCommitsRequest) (*gitalypb.CountCommitsResponse, error)) *MockCommitServiceServerCountCommitsCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockCommitServiceServerCountCommitsCall) DoAndReturn(f func(context.Context, *gitalypb.CountCommitsRequest) (*gitalypb.CountCommitsResponse, error)) *MockCommitServiceServerCountCommitsCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// CountDivergingCommits mocks base method.
func (m *MockCommitServiceServer) CountDivergingCommits(arg0 context.Context, arg1 *gitalypb.CountDivergingCommitsRequest) (*gitalypb.CountDivergingCommitsResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CountDivergingCommits", arg0, arg1)
	ret0, _ := ret[0].(*gitalypb.CountDivergingCommitsResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

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

// Return rewrite *gomock.Call.Return
func (c *MockCommitServiceServerCountDivergingCommitsCall) Return(arg0 *gitalypb.CountDivergingCommitsResponse, arg1 error) *MockCommitServiceServerCountDivergingCommitsCall {
	c.Call = c.Call.Return(arg0, arg1)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockCommitServiceServerCountDivergingCommitsCall) Do(f func(context.Context, *gitalypb.CountDivergingCommitsRequest) (*gitalypb.CountDivergingCommitsResponse, error)) *MockCommitServiceServerCountDivergingCommitsCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockCommitServiceServerCountDivergingCommitsCall) DoAndReturn(f func(context.Context, *gitalypb.CountDivergingCommitsRequest) (*gitalypb.CountDivergingCommitsResponse, error)) *MockCommitServiceServerCountDivergingCommitsCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// FilterShasWithSignatures mocks base method.
func (m *MockCommitServiceServer) FilterShasWithSignatures(arg0 grpc.BidiStreamingServer[gitalypb.FilterShasWithSignaturesRequest, gitalypb.FilterShasWithSignaturesResponse]) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "FilterShasWithSignatures", arg0)
	ret0, _ := ret[0].(error)
	return ret0
}

// FilterShasWithSignatures indicates an expected call of FilterShasWithSignatures.
func (mr *MockCommitServiceServerMockRecorder) FilterShasWithSignatures(arg0 any) *MockCommitServiceServerFilterShasWithSignaturesCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FilterShasWithSignatures", reflect.TypeOf((*MockCommitServiceServer)(nil).FilterShasWithSignatures), arg0)
	return &MockCommitServiceServerFilterShasWithSignaturesCall{Call: call}
}

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

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

// Do rewrite *gomock.Call.Do
func (c *MockCommitServiceServerFilterShasWithSignaturesCall) Do(f func(grpc.BidiStreamingServer[gitalypb.FilterShasWithSignaturesRequest, gitalypb.FilterShasWithSignaturesResponse]) error) *MockCommitServiceServerFilterShasWithSignaturesCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockCommitServiceServerFilterShasWithSignaturesCall) DoAndReturn(f func(grpc.BidiStreamingServer[gitalypb.FilterShasWithSignaturesRequest, gitalypb.FilterShasWithSignaturesResponse]) error) *MockCommitServiceServerFilterShasWithSignaturesCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// FindAllCommits mocks base method.
func (m *MockCommitServiceServer) FindAllCommits(arg0 *gitalypb.FindAllCommitsRequest, arg1 grpc.ServerStreamingServer[gitalypb.FindAllCommitsResponse]) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "FindAllCommits", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

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

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

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

// Do rewrite *gomock.Call.Do
func (c *MockCommitServiceServerFindAllCommitsCall) Do(f func(*gitalypb.FindAllCommitsRequest, grpc.ServerStreamingServer[gitalypb.FindAllCommitsResponse]) error) *MockCommitServiceServerFindAllCommitsCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockCommitServiceServerFindAllCommitsCall) DoAndReturn(f func(*gitalypb.FindAllCommitsRequest, grpc.ServerStreamingServer[gitalypb.FindAllCommitsResponse]) error) *MockCommitServiceServerFindAllCommitsCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// FindCommit mocks base method.
func (m *MockCommitServiceServer) FindCommit(arg0 context.Context, arg1 *gitalypb.FindCommitRequest) (*gitalypb.FindCommitResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "FindCommit", arg0, arg1)
	ret0, _ := ret[0].(*gitalypb.FindCommitResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

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

// Return rewrite *gomock.Call.Return
func (c *MockCommitServiceServerFindCommitCall) Return(arg0 *gitalypb.FindCommitResponse, arg1 error) *MockCommitServiceServerFindCommitCall {
	c.Call = c.Call.Return(arg0, arg1)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockCommitServiceServerFindCommitCall) Do(f func(context.Context, *gitalypb.FindCommitRequest) (*gitalypb.FindCommitResponse, error)) *MockCommitServiceServerFindCommitCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockCommitServiceServerFindCommitCall) DoAndReturn(f func(context.Context, *gitalypb.FindCommitRequest) (*gitalypb.FindCommitResponse, error)) *MockCommitServiceServerFindCommitCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// FindCommits mocks base method.
func (m *MockCommitServiceServer) FindCommits(arg0 *gitalypb.FindCommitsRequest, arg1 grpc.ServerStreamingServer[gitalypb.FindCommitsResponse]) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "FindCommits", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

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

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

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

// Do rewrite *gomock.Call.Do
func (c *MockCommitServiceServerFindCommitsCall) Do(f func(*gitalypb.FindCommitsRequest, grpc.ServerStreamingServer[gitalypb.FindCommitsResponse]) error) *MockCommitServiceServerFindCommitsCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockCommitServiceServerFindCommitsCall) DoAndReturn(f func(*gitalypb.FindCommitsRequest, grpc.ServerStreamingServer[gitalypb.FindCommitsResponse]) error) *MockCommitServiceServerFindCommitsCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// GetCommitMessages mocks base method.
func (m *MockCommitServiceServer) GetCommitMessages(arg0 *gitalypb.GetCommitMessagesRequest, arg1 grpc.ServerStreamingServer[gitalypb.GetCommitMessagesResponse]) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetCommitMessages", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

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

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

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

// Do rewrite *gomock.Call.Do
func (c *MockCommitServiceServerGetCommitMessagesCall) Do(f func(*gitalypb.GetCommitMessagesRequest, grpc.ServerStreamingServer[gitalypb.GetCommitMessagesResponse]) error) *MockCommitServiceServerGetCommitMessagesCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockCommitServiceServerGetCommitMessagesCall) DoAndReturn(f func(*gitalypb.GetCommitMessagesRequest, grpc.ServerStreamingServer[gitalypb.GetCommitMessagesResponse]) error) *MockCommitServiceServerGetCommitMessagesCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// GetCommitSignatures mocks base method.
func (m *MockCommitServiceServer) GetCommitSignatures(arg0 *gitalypb.GetCommitSignaturesRequest, arg1 grpc.ServerStreamingServer[gitalypb.GetCommitSignaturesResponse]) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetCommitSignatures", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

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

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

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

// Do rewrite *gomock.Call.Do
func (c *MockCommitServiceServerGetCommitSignaturesCall) Do(f func(*gitalypb.GetCommitSignaturesRequest, grpc.ServerStreamingServer[gitalypb.GetCommitSignaturesResponse]) error) *MockCommitServiceServerGetCommitSignaturesCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockCommitServiceServerGetCommitSignaturesCall) DoAndReturn(f func(*gitalypb.GetCommitSignaturesRequest, grpc.ServerStreamingServer[gitalypb.GetCommitSignaturesResponse]) error) *MockCommitServiceServerGetCommitSignaturesCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// GetTreeEntries mocks base method.
func (m *MockCommitServiceServer) GetTreeEntries(arg0 *gitalypb.GetTreeEntriesRequest, arg1 grpc.ServerStreamingServer[gitalypb.GetTreeEntriesResponse]) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetTreeEntries", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

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

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

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

// Do rewrite *gomock.Call.Do
func (c *MockCommitServiceServerGetTreeEntriesCall) Do(f func(*gitalypb.GetTreeEntriesRequest, grpc.ServerStreamingServer[gitalypb.GetTreeEntriesResponse]) error) *MockCommitServiceServerGetTreeEntriesCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockCommitServiceServerGetTreeEntriesCall) DoAndReturn(f func(*gitalypb.GetTreeEntriesRequest, grpc.ServerStreamingServer[gitalypb.GetTreeEntriesResponse]) error) *MockCommitServiceServerGetTreeEntriesCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// LastCommitForPath mocks base method.
func (m *MockCommitServiceServer) LastCommitForPath(arg0 context.Context, arg1 *gitalypb.LastCommitForPathRequest) (*gitalypb.LastCommitForPathResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "LastCommitForPath", arg0, arg1)
	ret0, _ := ret[0].(*gitalypb.LastCommitForPathResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

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

// Return rewrite *gomock.Call.Return
func (c *MockCommitServiceServerLastCommitForPathCall) Return(arg0 *gitalypb.LastCommitForPathResponse, arg1 error) *MockCommitServiceServerLastCommitForPathCall {
	c.Call = c.Call.Return(arg0, arg1)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockCommitServiceServerLastCommitForPathCall) Do(f func(context.Context, *gitalypb.LastCommitForPathRequest) (*gitalypb.LastCommitForPathResponse, error)) *MockCommitServiceServerLastCommitForPathCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockCommitServiceServerLastCommitForPathCall) DoAndReturn(f func(context.Context, *gitalypb.LastCommitForPathRequest) (*gitalypb.LastCommitForPathResponse, error)) *MockCommitServiceServerLastCommitForPathCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// ListAllCommits mocks base method.
func (m *MockCommitServiceServer) ListAllCommits(arg0 *gitalypb.ListAllCommitsRequest, arg1 grpc.ServerStreamingServer[gitalypb.ListAllCommitsResponse]) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListAllCommits", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

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

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

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

// Do rewrite *gomock.Call.Do
func (c *MockCommitServiceServerListAllCommitsCall) Do(f func(*gitalypb.ListAllCommitsRequest, grpc.ServerStreamingServer[gitalypb.ListAllCommitsResponse]) error) *MockCommitServiceServerListAllCommitsCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockCommitServiceServerListAllCommitsCall) DoAndReturn(f func(*gitalypb.ListAllCommitsRequest, grpc.ServerStreamingServer[gitalypb.ListAllCommitsResponse]) error) *MockCommitServiceServerListAllCommitsCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// ListCommits mocks base method.
func (m *MockCommitServiceServer) ListCommits(arg0 *gitalypb.ListCommitsRequest, arg1 grpc.ServerStreamingServer[gitalypb.ListCommitsResponse]) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListCommits", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

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

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

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

// Do rewrite *gomock.Call.Do
func (c *MockCommitServiceServerListCommitsCall) Do(f func(*gitalypb.ListCommitsRequest, grpc.ServerStreamingServer[gitalypb.ListCommitsResponse]) error) *MockCommitServiceServerListCommitsCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockCommitServiceServerListCommitsCall) DoAndReturn(f func(*gitalypb.ListCommitsRequest, grpc.ServerStreamingServer[gitalypb.ListCommitsResponse]) error) *MockCommitServiceServerListCommitsCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// ListCommitsByOid mocks base method.
func (m *MockCommitServiceServer) ListCommitsByOid(arg0 *gitalypb.ListCommitsByOidRequest, arg1 grpc.ServerStreamingServer[gitalypb.ListCommitsByOidResponse]) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListCommitsByOid", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

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

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

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

// Do rewrite *gomock.Call.Do
func (c *MockCommitServiceServerListCommitsByOidCall) Do(f func(*gitalypb.ListCommitsByOidRequest, grpc.ServerStreamingServer[gitalypb.ListCommitsByOidResponse]) error) *MockCommitServiceServerListCommitsByOidCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockCommitServiceServerListCommitsByOidCall) DoAndReturn(f func(*gitalypb.ListCommitsByOidRequest, grpc.ServerStreamingServer[gitalypb.ListCommitsByOidResponse]) error) *MockCommitServiceServerListCommitsByOidCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// ListCommitsByRefName mocks base method.
func (m *MockCommitServiceServer) ListCommitsByRefName(arg0 *gitalypb.ListCommitsByRefNameRequest, arg1 grpc.ServerStreamingServer[gitalypb.ListCommitsByRefNameResponse]) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListCommitsByRefName", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

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

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

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

// Do rewrite *gomock.Call.Do
func (c *MockCommitServiceServerListCommitsByRefNameCall) Do(f func(*gitalypb.ListCommitsByRefNameRequest, grpc.ServerStreamingServer[gitalypb.ListCommitsByRefNameResponse]) error) *MockCommitServiceServerListCommitsByRefNameCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockCommitServiceServerListCommitsByRefNameCall) DoAndReturn(f func(*gitalypb.ListCommitsByRefNameRequest, grpc.ServerStreamingServer[gitalypb.ListCommitsByRefNameResponse]) error) *MockCommitServiceServerListCommitsByRefNameCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// ListFiles mocks base method.
func (m *MockCommitServiceServer) ListFiles(arg0 *gitalypb.ListFilesRequest, arg1 grpc.ServerStreamingServer[gitalypb.ListFilesResponse]) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListFiles", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

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

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

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

// Do rewrite *gomock.Call.Do
func (c *MockCommitServiceServerListFilesCall) Do(f func(*gitalypb.ListFilesRequest, grpc.ServerStreamingServer[gitalypb.ListFilesResponse]) error) *MockCommitServiceServerListFilesCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockCommitServiceServerListFilesCall) DoAndReturn(f func(*gitalypb.ListFilesRequest, grpc.ServerStreamingServer[gitalypb.ListFilesResponse]) error) *MockCommitServiceServerListFilesCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// ListLastCommitsForTree mocks base method.
func (m *MockCommitServiceServer) ListLastCommitsForTree(arg0 *gitalypb.ListLastCommitsForTreeRequest, arg1 grpc.ServerStreamingServer[gitalypb.ListLastCommitsForTreeResponse]) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListLastCommitsForTree", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

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

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

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

// Do rewrite *gomock.Call.Do
func (c *MockCommitServiceServerListLastCommitsForTreeCall) Do(f func(*gitalypb.ListLastCommitsForTreeRequest, grpc.ServerStreamingServer[gitalypb.ListLastCommitsForTreeResponse]) error) *MockCommitServiceServerListLastCommitsForTreeCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockCommitServiceServerListLastCommitsForTreeCall) DoAndReturn(f func(*gitalypb.ListLastCommitsForTreeRequest, grpc.ServerStreamingServer[gitalypb.ListLastCommitsForTreeResponse]) error) *MockCommitServiceServerListLastCommitsForTreeCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// RawBlame mocks base method.
func (m *MockCommitServiceServer) RawBlame(arg0 *gitalypb.RawBlameRequest, arg1 grpc.ServerStreamingServer[gitalypb.RawBlameResponse]) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "RawBlame", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

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

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

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

// Do rewrite *gomock.Call.Do
func (c *MockCommitServiceServerRawBlameCall) Do(f func(*gitalypb.RawBlameRequest, grpc.ServerStreamingServer[gitalypb.RawBlameResponse]) error) *MockCommitServiceServerRawBlameCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockCommitServiceServerRawBlameCall) DoAndReturn(f func(*gitalypb.RawBlameRequest, grpc.ServerStreamingServer[gitalypb.RawBlameResponse]) error) *MockCommitServiceServerRawBlameCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// TreeEntry mocks base method.
func (m *MockCommitServiceServer) TreeEntry(arg0 *gitalypb.TreeEntryRequest, arg1 grpc.ServerStreamingServer[gitalypb.TreeEntryResponse]) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "TreeEntry", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

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

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

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

// Do rewrite *gomock.Call.Do
func (c *MockCommitServiceServerTreeEntryCall) Do(f func(*gitalypb.TreeEntryRequest, grpc.ServerStreamingServer[gitalypb.TreeEntryResponse]) error) *MockCommitServiceServerTreeEntryCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockCommitServiceServerTreeEntryCall) DoAndReturn(f func(*gitalypb.TreeEntryRequest, grpc.ServerStreamingServer[gitalypb.TreeEntryResponse]) error) *MockCommitServiceServerTreeEntryCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// mustEmbedUnimplementedCommitServiceServer mocks base method.
func (m *MockCommitServiceServer) mustEmbedUnimplementedCommitServiceServer() {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "mustEmbedUnimplementedCommitServiceServer")
}

// mustEmbedUnimplementedCommitServiceServer indicates an expected call of mustEmbedUnimplementedCommitServiceServer.
func (mr *MockCommitServiceServerMockRecorder) mustEmbedUnimplementedCommitServiceServer() *MockCommitServiceServermustEmbedUnimplementedCommitServiceServerCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "mustEmbedUnimplementedCommitServiceServer", reflect.TypeOf((*MockCommitServiceServer)(nil).mustEmbedUnimplementedCommitServiceServer))
	return &MockCommitServiceServermustEmbedUnimplementedCommitServiceServerCall{Call: call}
}

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

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

// Do rewrite *gomock.Call.Do
func (c *MockCommitServiceServermustEmbedUnimplementedCommitServiceServerCall) Do(f func()) *MockCommitServiceServermustEmbedUnimplementedCommitServiceServerCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockCommitServiceServermustEmbedUnimplementedCommitServiceServerCall) DoAndReturn(f func()) *MockCommitServiceServermustEmbedUnimplementedCommitServiceServerCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// MockUnsafeCommitServiceServer is a mock of UnsafeCommitServiceServer interface.
type MockUnsafeCommitServiceServer struct {
	ctrl     *gomock.Controller
	recorder *MockUnsafeCommitServiceServerMockRecorder
	isgomock struct{}
}

// MockUnsafeCommitServiceServerMockRecorder is the mock recorder for MockUnsafeCommitServiceServer.
type MockUnsafeCommitServiceServerMockRecorder struct {
	mock *MockUnsafeCommitServiceServer
}

// NewMockUnsafeCommitServiceServer creates a new mock instance.
func NewMockUnsafeCommitServiceServer(ctrl *gomock.Controller) *MockUnsafeCommitServiceServer {
	mock := &MockUnsafeCommitServiceServer{ctrl: ctrl}
	mock.recorder = &MockUnsafeCommitServiceServerMockRecorder{mock}
	return mock
}

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

// mustEmbedUnimplementedCommitServiceServer mocks base method.
func (m *MockUnsafeCommitServiceServer) mustEmbedUnimplementedCommitServiceServer() {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "mustEmbedUnimplementedCommitServiceServer")
}

// mustEmbedUnimplementedCommitServiceServer indicates an expected call of mustEmbedUnimplementedCommitServiceServer.
func (mr *MockUnsafeCommitServiceServerMockRecorder) mustEmbedUnimplementedCommitServiceServer() *MockUnsafeCommitServiceServermustEmbedUnimplementedCommitServiceServerCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "mustEmbedUnimplementedCommitServiceServer", reflect.TypeOf((*MockUnsafeCommitServiceServer)(nil).mustEmbedUnimplementedCommitServiceServer))
	return &MockUnsafeCommitServiceServermustEmbedUnimplementedCommitServiceServerCall{Call: call}
}

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

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

// Do rewrite *gomock.Call.Do
func (c *MockUnsafeCommitServiceServermustEmbedUnimplementedCommitServiceServerCall) Do(f func()) *MockUnsafeCommitServiceServermustEmbedUnimplementedCommitServiceServerCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockUnsafeCommitServiceServermustEmbedUnimplementedCommitServiceServerCall) DoAndReturn(f func()) *MockUnsafeCommitServiceServermustEmbedUnimplementedCommitServiceServerCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}
