// Code generated by MockGen. DO NOT EDIT.
// Source: gitlab.com/gitlab-org/api/client-go (interfaces: CommitsServiceInterface)
//
// Generated by this command:
//
//	mockgen -typed -destination=commits_mock.go -package=testing gitlab.com/gitlab-org/api/client-go CommitsServiceInterface
//

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

import (
	reflect "reflect"

	gitlab "gitlab.com/gitlab-org/api/client-go"
	gomock "go.uber.org/mock/gomock"
)

// MockCommitsServiceInterface is a mock of CommitsServiceInterface interface.
type MockCommitsServiceInterface struct {
	ctrl     *gomock.Controller
	recorder *MockCommitsServiceInterfaceMockRecorder
	isgomock struct{}
}

// MockCommitsServiceInterfaceMockRecorder is the mock recorder for MockCommitsServiceInterface.
type MockCommitsServiceInterfaceMockRecorder struct {
	mock *MockCommitsServiceInterface
}

// NewMockCommitsServiceInterface creates a new mock instance.
func NewMockCommitsServiceInterface(ctrl *gomock.Controller) *MockCommitsServiceInterface {
	mock := &MockCommitsServiceInterface{ctrl: ctrl}
	mock.recorder = &MockCommitsServiceInterfaceMockRecorder{mock}
	return mock
}

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

// CherryPickCommit mocks base method.
func (m *MockCommitsServiceInterface) CherryPickCommit(pid any, sha string, opt *gitlab.CherryPickCommitOptions, options ...gitlab.RequestOptionFunc) (*gitlab.Commit, *gitlab.Response, error) {
	m.ctrl.T.Helper()
	varargs := []any{pid, sha, opt}
	for _, a := range options {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "CherryPickCommit", varargs...)
	ret0, _ := ret[0].(*gitlab.Commit)
	ret1, _ := ret[1].(*gitlab.Response)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// CherryPickCommit indicates an expected call of CherryPickCommit.
func (mr *MockCommitsServiceInterfaceMockRecorder) CherryPickCommit(pid, sha, opt any, options ...any) *MockCommitsServiceInterfaceCherryPickCommitCall {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{pid, sha, opt}, options...)
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CherryPickCommit", reflect.TypeOf((*MockCommitsServiceInterface)(nil).CherryPickCommit), varargs...)
	return &MockCommitsServiceInterfaceCherryPickCommitCall{Call: call}
}

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

// Return rewrite *gomock.Call.Return
func (c *MockCommitsServiceInterfaceCherryPickCommitCall) Return(arg0 *gitlab.Commit, arg1 *gitlab.Response, arg2 error) *MockCommitsServiceInterfaceCherryPickCommitCall {
	c.Call = c.Call.Return(arg0, arg1, arg2)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockCommitsServiceInterfaceCherryPickCommitCall) Do(f func(any, string, *gitlab.CherryPickCommitOptions, ...gitlab.RequestOptionFunc) (*gitlab.Commit, *gitlab.Response, error)) *MockCommitsServiceInterfaceCherryPickCommitCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockCommitsServiceInterfaceCherryPickCommitCall) DoAndReturn(f func(any, string, *gitlab.CherryPickCommitOptions, ...gitlab.RequestOptionFunc) (*gitlab.Commit, *gitlab.Response, error)) *MockCommitsServiceInterfaceCherryPickCommitCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// CreateCommit mocks base method.
func (m *MockCommitsServiceInterface) CreateCommit(pid any, opt *gitlab.CreateCommitOptions, options ...gitlab.RequestOptionFunc) (*gitlab.Commit, *gitlab.Response, error) {
	m.ctrl.T.Helper()
	varargs := []any{pid, opt}
	for _, a := range options {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "CreateCommit", varargs...)
	ret0, _ := ret[0].(*gitlab.Commit)
	ret1, _ := ret[1].(*gitlab.Response)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// CreateCommit indicates an expected call of CreateCommit.
func (mr *MockCommitsServiceInterfaceMockRecorder) CreateCommit(pid, opt any, options ...any) *MockCommitsServiceInterfaceCreateCommitCall {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{pid, opt}, options...)
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateCommit", reflect.TypeOf((*MockCommitsServiceInterface)(nil).CreateCommit), varargs...)
	return &MockCommitsServiceInterfaceCreateCommitCall{Call: call}
}

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

// Return rewrite *gomock.Call.Return
func (c *MockCommitsServiceInterfaceCreateCommitCall) Return(arg0 *gitlab.Commit, arg1 *gitlab.Response, arg2 error) *MockCommitsServiceInterfaceCreateCommitCall {
	c.Call = c.Call.Return(arg0, arg1, arg2)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockCommitsServiceInterfaceCreateCommitCall) Do(f func(any, *gitlab.CreateCommitOptions, ...gitlab.RequestOptionFunc) (*gitlab.Commit, *gitlab.Response, error)) *MockCommitsServiceInterfaceCreateCommitCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockCommitsServiceInterfaceCreateCommitCall) DoAndReturn(f func(any, *gitlab.CreateCommitOptions, ...gitlab.RequestOptionFunc) (*gitlab.Commit, *gitlab.Response, error)) *MockCommitsServiceInterfaceCreateCommitCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// GetCommit mocks base method.
func (m *MockCommitsServiceInterface) GetCommit(pid any, sha string, opt *gitlab.GetCommitOptions, options ...gitlab.RequestOptionFunc) (*gitlab.Commit, *gitlab.Response, error) {
	m.ctrl.T.Helper()
	varargs := []any{pid, sha, opt}
	for _, a := range options {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetCommit", varargs...)
	ret0, _ := ret[0].(*gitlab.Commit)
	ret1, _ := ret[1].(*gitlab.Response)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// GetCommit indicates an expected call of GetCommit.
func (mr *MockCommitsServiceInterfaceMockRecorder) GetCommit(pid, sha, opt any, options ...any) *MockCommitsServiceInterfaceGetCommitCall {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{pid, sha, opt}, options...)
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetCommit", reflect.TypeOf((*MockCommitsServiceInterface)(nil).GetCommit), varargs...)
	return &MockCommitsServiceInterfaceGetCommitCall{Call: call}
}

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

// Return rewrite *gomock.Call.Return
func (c *MockCommitsServiceInterfaceGetCommitCall) Return(arg0 *gitlab.Commit, arg1 *gitlab.Response, arg2 error) *MockCommitsServiceInterfaceGetCommitCall {
	c.Call = c.Call.Return(arg0, arg1, arg2)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockCommitsServiceInterfaceGetCommitCall) Do(f func(any, string, *gitlab.GetCommitOptions, ...gitlab.RequestOptionFunc) (*gitlab.Commit, *gitlab.Response, error)) *MockCommitsServiceInterfaceGetCommitCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockCommitsServiceInterfaceGetCommitCall) DoAndReturn(f func(any, string, *gitlab.GetCommitOptions, ...gitlab.RequestOptionFunc) (*gitlab.Commit, *gitlab.Response, error)) *MockCommitsServiceInterfaceGetCommitCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// GetCommitComments mocks base method.
func (m *MockCommitsServiceInterface) GetCommitComments(pid any, sha string, opt *gitlab.GetCommitCommentsOptions, options ...gitlab.RequestOptionFunc) ([]*gitlab.CommitComment, *gitlab.Response, error) {
	m.ctrl.T.Helper()
	varargs := []any{pid, sha, opt}
	for _, a := range options {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetCommitComments", varargs...)
	ret0, _ := ret[0].([]*gitlab.CommitComment)
	ret1, _ := ret[1].(*gitlab.Response)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// GetCommitComments indicates an expected call of GetCommitComments.
func (mr *MockCommitsServiceInterfaceMockRecorder) GetCommitComments(pid, sha, opt any, options ...any) *MockCommitsServiceInterfaceGetCommitCommentsCall {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{pid, sha, opt}, options...)
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetCommitComments", reflect.TypeOf((*MockCommitsServiceInterface)(nil).GetCommitComments), varargs...)
	return &MockCommitsServiceInterfaceGetCommitCommentsCall{Call: call}
}

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

// Return rewrite *gomock.Call.Return
func (c *MockCommitsServiceInterfaceGetCommitCommentsCall) Return(arg0 []*gitlab.CommitComment, arg1 *gitlab.Response, arg2 error) *MockCommitsServiceInterfaceGetCommitCommentsCall {
	c.Call = c.Call.Return(arg0, arg1, arg2)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockCommitsServiceInterfaceGetCommitCommentsCall) Do(f func(any, string, *gitlab.GetCommitCommentsOptions, ...gitlab.RequestOptionFunc) ([]*gitlab.CommitComment, *gitlab.Response, error)) *MockCommitsServiceInterfaceGetCommitCommentsCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockCommitsServiceInterfaceGetCommitCommentsCall) DoAndReturn(f func(any, string, *gitlab.GetCommitCommentsOptions, ...gitlab.RequestOptionFunc) ([]*gitlab.CommitComment, *gitlab.Response, error)) *MockCommitsServiceInterfaceGetCommitCommentsCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// GetCommitDiff mocks base method.
func (m *MockCommitsServiceInterface) GetCommitDiff(pid any, sha string, opt *gitlab.GetCommitDiffOptions, options ...gitlab.RequestOptionFunc) ([]*gitlab.Diff, *gitlab.Response, error) {
	m.ctrl.T.Helper()
	varargs := []any{pid, sha, opt}
	for _, a := range options {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetCommitDiff", varargs...)
	ret0, _ := ret[0].([]*gitlab.Diff)
	ret1, _ := ret[1].(*gitlab.Response)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// GetCommitDiff indicates an expected call of GetCommitDiff.
func (mr *MockCommitsServiceInterfaceMockRecorder) GetCommitDiff(pid, sha, opt any, options ...any) *MockCommitsServiceInterfaceGetCommitDiffCall {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{pid, sha, opt}, options...)
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetCommitDiff", reflect.TypeOf((*MockCommitsServiceInterface)(nil).GetCommitDiff), varargs...)
	return &MockCommitsServiceInterfaceGetCommitDiffCall{Call: call}
}

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

// Return rewrite *gomock.Call.Return
func (c *MockCommitsServiceInterfaceGetCommitDiffCall) Return(arg0 []*gitlab.Diff, arg1 *gitlab.Response, arg2 error) *MockCommitsServiceInterfaceGetCommitDiffCall {
	c.Call = c.Call.Return(arg0, arg1, arg2)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockCommitsServiceInterfaceGetCommitDiffCall) Do(f func(any, string, *gitlab.GetCommitDiffOptions, ...gitlab.RequestOptionFunc) ([]*gitlab.Diff, *gitlab.Response, error)) *MockCommitsServiceInterfaceGetCommitDiffCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockCommitsServiceInterfaceGetCommitDiffCall) DoAndReturn(f func(any, string, *gitlab.GetCommitDiffOptions, ...gitlab.RequestOptionFunc) ([]*gitlab.Diff, *gitlab.Response, error)) *MockCommitsServiceInterfaceGetCommitDiffCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// GetCommitRefs mocks base method.
func (m *MockCommitsServiceInterface) GetCommitRefs(pid any, sha string, opt *gitlab.GetCommitRefsOptions, options ...gitlab.RequestOptionFunc) ([]*gitlab.CommitRef, *gitlab.Response, error) {
	m.ctrl.T.Helper()
	varargs := []any{pid, sha, opt}
	for _, a := range options {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetCommitRefs", varargs...)
	ret0, _ := ret[0].([]*gitlab.CommitRef)
	ret1, _ := ret[1].(*gitlab.Response)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// GetCommitRefs indicates an expected call of GetCommitRefs.
func (mr *MockCommitsServiceInterfaceMockRecorder) GetCommitRefs(pid, sha, opt any, options ...any) *MockCommitsServiceInterfaceGetCommitRefsCall {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{pid, sha, opt}, options...)
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetCommitRefs", reflect.TypeOf((*MockCommitsServiceInterface)(nil).GetCommitRefs), varargs...)
	return &MockCommitsServiceInterfaceGetCommitRefsCall{Call: call}
}

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

// Return rewrite *gomock.Call.Return
func (c *MockCommitsServiceInterfaceGetCommitRefsCall) Return(arg0 []*gitlab.CommitRef, arg1 *gitlab.Response, arg2 error) *MockCommitsServiceInterfaceGetCommitRefsCall {
	c.Call = c.Call.Return(arg0, arg1, arg2)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockCommitsServiceInterfaceGetCommitRefsCall) Do(f func(any, string, *gitlab.GetCommitRefsOptions, ...gitlab.RequestOptionFunc) ([]*gitlab.CommitRef, *gitlab.Response, error)) *MockCommitsServiceInterfaceGetCommitRefsCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockCommitsServiceInterfaceGetCommitRefsCall) DoAndReturn(f func(any, string, *gitlab.GetCommitRefsOptions, ...gitlab.RequestOptionFunc) ([]*gitlab.CommitRef, *gitlab.Response, error)) *MockCommitsServiceInterfaceGetCommitRefsCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// GetCommitStatuses mocks base method.
func (m *MockCommitsServiceInterface) GetCommitStatuses(pid any, sha string, opt *gitlab.GetCommitStatusesOptions, options ...gitlab.RequestOptionFunc) ([]*gitlab.CommitStatus, *gitlab.Response, error) {
	m.ctrl.T.Helper()
	varargs := []any{pid, sha, opt}
	for _, a := range options {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetCommitStatuses", varargs...)
	ret0, _ := ret[0].([]*gitlab.CommitStatus)
	ret1, _ := ret[1].(*gitlab.Response)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// GetCommitStatuses indicates an expected call of GetCommitStatuses.
func (mr *MockCommitsServiceInterfaceMockRecorder) GetCommitStatuses(pid, sha, opt any, options ...any) *MockCommitsServiceInterfaceGetCommitStatusesCall {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{pid, sha, opt}, options...)
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetCommitStatuses", reflect.TypeOf((*MockCommitsServiceInterface)(nil).GetCommitStatuses), varargs...)
	return &MockCommitsServiceInterfaceGetCommitStatusesCall{Call: call}
}

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

// Return rewrite *gomock.Call.Return
func (c *MockCommitsServiceInterfaceGetCommitStatusesCall) Return(arg0 []*gitlab.CommitStatus, arg1 *gitlab.Response, arg2 error) *MockCommitsServiceInterfaceGetCommitStatusesCall {
	c.Call = c.Call.Return(arg0, arg1, arg2)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockCommitsServiceInterfaceGetCommitStatusesCall) Do(f func(any, string, *gitlab.GetCommitStatusesOptions, ...gitlab.RequestOptionFunc) ([]*gitlab.CommitStatus, *gitlab.Response, error)) *MockCommitsServiceInterfaceGetCommitStatusesCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockCommitsServiceInterfaceGetCommitStatusesCall) DoAndReturn(f func(any, string, *gitlab.GetCommitStatusesOptions, ...gitlab.RequestOptionFunc) ([]*gitlab.CommitStatus, *gitlab.Response, error)) *MockCommitsServiceInterfaceGetCommitStatusesCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// GetGPGSignature mocks base method.
func (m *MockCommitsServiceInterface) GetGPGSignature(pid any, sha string, options ...gitlab.RequestOptionFunc) (*gitlab.GPGSignature, *gitlab.Response, error) {
	m.ctrl.T.Helper()
	varargs := []any{pid, sha}
	for _, a := range options {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetGPGSignature", varargs...)
	ret0, _ := ret[0].(*gitlab.GPGSignature)
	ret1, _ := ret[1].(*gitlab.Response)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// GetGPGSignature indicates an expected call of GetGPGSignature.
func (mr *MockCommitsServiceInterfaceMockRecorder) GetGPGSignature(pid, sha any, options ...any) *MockCommitsServiceInterfaceGetGPGSignatureCall {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{pid, sha}, options...)
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetGPGSignature", reflect.TypeOf((*MockCommitsServiceInterface)(nil).GetGPGSignature), varargs...)
	return &MockCommitsServiceInterfaceGetGPGSignatureCall{Call: call}
}

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

// Return rewrite *gomock.Call.Return
func (c *MockCommitsServiceInterfaceGetGPGSignatureCall) Return(arg0 *gitlab.GPGSignature, arg1 *gitlab.Response, arg2 error) *MockCommitsServiceInterfaceGetGPGSignatureCall {
	c.Call = c.Call.Return(arg0, arg1, arg2)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockCommitsServiceInterfaceGetGPGSignatureCall) Do(f func(any, string, ...gitlab.RequestOptionFunc) (*gitlab.GPGSignature, *gitlab.Response, error)) *MockCommitsServiceInterfaceGetGPGSignatureCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockCommitsServiceInterfaceGetGPGSignatureCall) DoAndReturn(f func(any, string, ...gitlab.RequestOptionFunc) (*gitlab.GPGSignature, *gitlab.Response, error)) *MockCommitsServiceInterfaceGetGPGSignatureCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// ListCommits mocks base method.
func (m *MockCommitsServiceInterface) ListCommits(pid any, opt *gitlab.ListCommitsOptions, options ...gitlab.RequestOptionFunc) ([]*gitlab.Commit, *gitlab.Response, error) {
	m.ctrl.T.Helper()
	varargs := []any{pid, opt}
	for _, a := range options {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListCommits", varargs...)
	ret0, _ := ret[0].([]*gitlab.Commit)
	ret1, _ := ret[1].(*gitlab.Response)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// ListCommits indicates an expected call of ListCommits.
func (mr *MockCommitsServiceInterfaceMockRecorder) ListCommits(pid, opt any, options ...any) *MockCommitsServiceInterfaceListCommitsCall {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{pid, opt}, options...)
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListCommits", reflect.TypeOf((*MockCommitsServiceInterface)(nil).ListCommits), varargs...)
	return &MockCommitsServiceInterfaceListCommitsCall{Call: call}
}

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

// Return rewrite *gomock.Call.Return
func (c *MockCommitsServiceInterfaceListCommitsCall) Return(arg0 []*gitlab.Commit, arg1 *gitlab.Response, arg2 error) *MockCommitsServiceInterfaceListCommitsCall {
	c.Call = c.Call.Return(arg0, arg1, arg2)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockCommitsServiceInterfaceListCommitsCall) Do(f func(any, *gitlab.ListCommitsOptions, ...gitlab.RequestOptionFunc) ([]*gitlab.Commit, *gitlab.Response, error)) *MockCommitsServiceInterfaceListCommitsCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockCommitsServiceInterfaceListCommitsCall) DoAndReturn(f func(any, *gitlab.ListCommitsOptions, ...gitlab.RequestOptionFunc) ([]*gitlab.Commit, *gitlab.Response, error)) *MockCommitsServiceInterfaceListCommitsCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// ListMergeRequestsByCommit mocks base method.
func (m *MockCommitsServiceInterface) ListMergeRequestsByCommit(pid any, sha string, options ...gitlab.RequestOptionFunc) ([]*gitlab.BasicMergeRequest, *gitlab.Response, error) {
	m.ctrl.T.Helper()
	varargs := []any{pid, sha}
	for _, a := range options {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListMergeRequestsByCommit", varargs...)
	ret0, _ := ret[0].([]*gitlab.BasicMergeRequest)
	ret1, _ := ret[1].(*gitlab.Response)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// ListMergeRequestsByCommit indicates an expected call of ListMergeRequestsByCommit.
func (mr *MockCommitsServiceInterfaceMockRecorder) ListMergeRequestsByCommit(pid, sha any, options ...any) *MockCommitsServiceInterfaceListMergeRequestsByCommitCall {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{pid, sha}, options...)
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListMergeRequestsByCommit", reflect.TypeOf((*MockCommitsServiceInterface)(nil).ListMergeRequestsByCommit), varargs...)
	return &MockCommitsServiceInterfaceListMergeRequestsByCommitCall{Call: call}
}

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

// Return rewrite *gomock.Call.Return
func (c *MockCommitsServiceInterfaceListMergeRequestsByCommitCall) Return(arg0 []*gitlab.BasicMergeRequest, arg1 *gitlab.Response, arg2 error) *MockCommitsServiceInterfaceListMergeRequestsByCommitCall {
	c.Call = c.Call.Return(arg0, arg1, arg2)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockCommitsServiceInterfaceListMergeRequestsByCommitCall) Do(f func(any, string, ...gitlab.RequestOptionFunc) ([]*gitlab.BasicMergeRequest, *gitlab.Response, error)) *MockCommitsServiceInterfaceListMergeRequestsByCommitCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockCommitsServiceInterfaceListMergeRequestsByCommitCall) DoAndReturn(f func(any, string, ...gitlab.RequestOptionFunc) ([]*gitlab.BasicMergeRequest, *gitlab.Response, error)) *MockCommitsServiceInterfaceListMergeRequestsByCommitCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// PostCommitComment mocks base method.
func (m *MockCommitsServiceInterface) PostCommitComment(pid any, sha string, opt *gitlab.PostCommitCommentOptions, options ...gitlab.RequestOptionFunc) (*gitlab.CommitComment, *gitlab.Response, error) {
	m.ctrl.T.Helper()
	varargs := []any{pid, sha, opt}
	for _, a := range options {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "PostCommitComment", varargs...)
	ret0, _ := ret[0].(*gitlab.CommitComment)
	ret1, _ := ret[1].(*gitlab.Response)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// PostCommitComment indicates an expected call of PostCommitComment.
func (mr *MockCommitsServiceInterfaceMockRecorder) PostCommitComment(pid, sha, opt any, options ...any) *MockCommitsServiceInterfacePostCommitCommentCall {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{pid, sha, opt}, options...)
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PostCommitComment", reflect.TypeOf((*MockCommitsServiceInterface)(nil).PostCommitComment), varargs...)
	return &MockCommitsServiceInterfacePostCommitCommentCall{Call: call}
}

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

// Return rewrite *gomock.Call.Return
func (c *MockCommitsServiceInterfacePostCommitCommentCall) Return(arg0 *gitlab.CommitComment, arg1 *gitlab.Response, arg2 error) *MockCommitsServiceInterfacePostCommitCommentCall {
	c.Call = c.Call.Return(arg0, arg1, arg2)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockCommitsServiceInterfacePostCommitCommentCall) Do(f func(any, string, *gitlab.PostCommitCommentOptions, ...gitlab.RequestOptionFunc) (*gitlab.CommitComment, *gitlab.Response, error)) *MockCommitsServiceInterfacePostCommitCommentCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockCommitsServiceInterfacePostCommitCommentCall) DoAndReturn(f func(any, string, *gitlab.PostCommitCommentOptions, ...gitlab.RequestOptionFunc) (*gitlab.CommitComment, *gitlab.Response, error)) *MockCommitsServiceInterfacePostCommitCommentCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// RevertCommit mocks base method.
func (m *MockCommitsServiceInterface) RevertCommit(pid any, sha string, opt *gitlab.RevertCommitOptions, options ...gitlab.RequestOptionFunc) (*gitlab.Commit, *gitlab.Response, error) {
	m.ctrl.T.Helper()
	varargs := []any{pid, sha, opt}
	for _, a := range options {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "RevertCommit", varargs...)
	ret0, _ := ret[0].(*gitlab.Commit)
	ret1, _ := ret[1].(*gitlab.Response)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// RevertCommit indicates an expected call of RevertCommit.
func (mr *MockCommitsServiceInterfaceMockRecorder) RevertCommit(pid, sha, opt any, options ...any) *MockCommitsServiceInterfaceRevertCommitCall {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{pid, sha, opt}, options...)
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RevertCommit", reflect.TypeOf((*MockCommitsServiceInterface)(nil).RevertCommit), varargs...)
	return &MockCommitsServiceInterfaceRevertCommitCall{Call: call}
}

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

// Return rewrite *gomock.Call.Return
func (c *MockCommitsServiceInterfaceRevertCommitCall) Return(arg0 *gitlab.Commit, arg1 *gitlab.Response, arg2 error) *MockCommitsServiceInterfaceRevertCommitCall {
	c.Call = c.Call.Return(arg0, arg1, arg2)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockCommitsServiceInterfaceRevertCommitCall) Do(f func(any, string, *gitlab.RevertCommitOptions, ...gitlab.RequestOptionFunc) (*gitlab.Commit, *gitlab.Response, error)) *MockCommitsServiceInterfaceRevertCommitCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockCommitsServiceInterfaceRevertCommitCall) DoAndReturn(f func(any, string, *gitlab.RevertCommitOptions, ...gitlab.RequestOptionFunc) (*gitlab.Commit, *gitlab.Response, error)) *MockCommitsServiceInterfaceRevertCommitCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// SetCommitStatus mocks base method.
func (m *MockCommitsServiceInterface) SetCommitStatus(pid any, sha string, opt *gitlab.SetCommitStatusOptions, options ...gitlab.RequestOptionFunc) (*gitlab.CommitStatus, *gitlab.Response, error) {
	m.ctrl.T.Helper()
	varargs := []any{pid, sha, opt}
	for _, a := range options {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "SetCommitStatus", varargs...)
	ret0, _ := ret[0].(*gitlab.CommitStatus)
	ret1, _ := ret[1].(*gitlab.Response)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// SetCommitStatus indicates an expected call of SetCommitStatus.
func (mr *MockCommitsServiceInterfaceMockRecorder) SetCommitStatus(pid, sha, opt any, options ...any) *MockCommitsServiceInterfaceSetCommitStatusCall {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{pid, sha, opt}, options...)
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetCommitStatus", reflect.TypeOf((*MockCommitsServiceInterface)(nil).SetCommitStatus), varargs...)
	return &MockCommitsServiceInterfaceSetCommitStatusCall{Call: call}
}

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

// Return rewrite *gomock.Call.Return
func (c *MockCommitsServiceInterfaceSetCommitStatusCall) Return(arg0 *gitlab.CommitStatus, arg1 *gitlab.Response, arg2 error) *MockCommitsServiceInterfaceSetCommitStatusCall {
	c.Call = c.Call.Return(arg0, arg1, arg2)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockCommitsServiceInterfaceSetCommitStatusCall) Do(f func(any, string, *gitlab.SetCommitStatusOptions, ...gitlab.RequestOptionFunc) (*gitlab.CommitStatus, *gitlab.Response, error)) *MockCommitsServiceInterfaceSetCommitStatusCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockCommitsServiceInterfaceSetCommitStatusCall) DoAndReturn(f func(any, string, *gitlab.SetCommitStatusOptions, ...gitlab.RequestOptionFunc) (*gitlab.CommitStatus, *gitlab.Response, error)) *MockCommitsServiceInterfaceSetCommitStatusCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}
