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

package testing

import (
	io "io"
	reflect "reflect"

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

// MockRepositoriesServiceInterface is a mock of RepositoriesServiceInterface interface.
type MockRepositoriesServiceInterface struct {
	ctrl     *gomock.Controller
	recorder *MockRepositoriesServiceInterfaceMockRecorder
	isgomock struct{}
}

// MockRepositoriesServiceInterfaceMockRecorder is the mock recorder for MockRepositoriesServiceInterface.
type MockRepositoriesServiceInterfaceMockRecorder struct {
	mock *MockRepositoriesServiceInterface
}

// NewMockRepositoriesServiceInterface creates a new mock instance.
func NewMockRepositoriesServiceInterface(ctrl *gomock.Controller) *MockRepositoriesServiceInterface {
	mock := &MockRepositoriesServiceInterface{ctrl: ctrl}
	mock.recorder = &MockRepositoriesServiceInterfaceMockRecorder{mock}
	return mock
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

// Do rewrite *gomock.Call.Do
func (c *MockRepositoriesServiceInterfaceCompareCall) Do(f func(any, *gitlab.CompareOptions, ...gitlab.RequestOptionFunc) (*gitlab.Compare, *gitlab.Response, error)) *MockRepositoriesServiceInterfaceCompareCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockRepositoriesServiceInterfaceCompareCall) DoAndReturn(f func(any, *gitlab.CompareOptions, ...gitlab.RequestOptionFunc) (*gitlab.Compare, *gitlab.Response, error)) *MockRepositoriesServiceInterfaceCompareCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

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

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

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

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

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

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

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

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

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

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

// Do rewrite *gomock.Call.Do
func (c *MockRepositoriesServiceInterfaceGenerateChangelogDataCall) Do(f func(any, gitlab.GenerateChangelogDataOptions, ...gitlab.RequestOptionFunc) (*gitlab.ChangelogData, *gitlab.Response, error)) *MockRepositoriesServiceInterfaceGenerateChangelogDataCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockRepositoriesServiceInterfaceGenerateChangelogDataCall) DoAndReturn(f func(any, gitlab.GenerateChangelogDataOptions, ...gitlab.RequestOptionFunc) (*gitlab.ChangelogData, *gitlab.Response, error)) *MockRepositoriesServiceInterfaceGenerateChangelogDataCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

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

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

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

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

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

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

// MergeBase mocks base method.
func (m *MockRepositoriesServiceInterface) MergeBase(pid any, opt *gitlab.MergeBaseOptions, 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, "MergeBase", varargs...)
	ret0, _ := ret[0].(*gitlab.Commit)
	ret1, _ := ret[1].(*gitlab.Response)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

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

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

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

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

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

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

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

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

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

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

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

// StreamArchive mocks base method.
func (m *MockRepositoriesServiceInterface) StreamArchive(pid any, w io.Writer, opt *gitlab.ArchiveOptions, options ...gitlab.RequestOptionFunc) (*gitlab.Response, error) {
	m.ctrl.T.Helper()
	varargs := []any{pid, w, opt}
	for _, a := range options {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "StreamArchive", varargs...)
	ret0, _ := ret[0].(*gitlab.Response)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

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

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

// Do rewrite *gomock.Call.Do
func (c *MockRepositoriesServiceInterfaceStreamArchiveCall) Do(f func(any, io.Writer, *gitlab.ArchiveOptions, ...gitlab.RequestOptionFunc) (*gitlab.Response, error)) *MockRepositoriesServiceInterfaceStreamArchiveCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockRepositoriesServiceInterfaceStreamArchiveCall) DoAndReturn(f func(any, io.Writer, *gitlab.ArchiveOptions, ...gitlab.RequestOptionFunc) (*gitlab.Response, error)) *MockRepositoriesServiceInterfaceStreamArchiveCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}
