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

package testing

import (
	reflect "reflect"

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

// MockContainerRegistryServiceInterface is a mock of ContainerRegistryServiceInterface interface.
type MockContainerRegistryServiceInterface struct {
	ctrl     *gomock.Controller
	recorder *MockContainerRegistryServiceInterfaceMockRecorder
	isgomock struct{}
}

// MockContainerRegistryServiceInterfaceMockRecorder is the mock recorder for MockContainerRegistryServiceInterface.
type MockContainerRegistryServiceInterfaceMockRecorder struct {
	mock *MockContainerRegistryServiceInterface
}

// NewMockContainerRegistryServiceInterface creates a new mock instance.
func NewMockContainerRegistryServiceInterface(ctrl *gomock.Controller) *MockContainerRegistryServiceInterface {
	mock := &MockContainerRegistryServiceInterface{ctrl: ctrl}
	mock.recorder = &MockContainerRegistryServiceInterfaceMockRecorder{mock}
	return mock
}

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

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

// DeleteRegistryRepository indicates an expected call of DeleteRegistryRepository.
func (mr *MockContainerRegistryServiceInterfaceMockRecorder) DeleteRegistryRepository(pid, repository any, options ...any) *MockContainerRegistryServiceInterfaceDeleteRegistryRepositoryCall {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{pid, repository}, options...)
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteRegistryRepository", reflect.TypeOf((*MockContainerRegistryServiceInterface)(nil).DeleteRegistryRepository), varargs...)
	return &MockContainerRegistryServiceInterfaceDeleteRegistryRepositoryCall{Call: call}
}

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

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

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

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

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

// DeleteRegistryRepositoryTag indicates an expected call of DeleteRegistryRepositoryTag.
func (mr *MockContainerRegistryServiceInterfaceMockRecorder) DeleteRegistryRepositoryTag(pid, repository, tagName any, options ...any) *MockContainerRegistryServiceInterfaceDeleteRegistryRepositoryTagCall {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{pid, repository, tagName}, options...)
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteRegistryRepositoryTag", reflect.TypeOf((*MockContainerRegistryServiceInterface)(nil).DeleteRegistryRepositoryTag), varargs...)
	return &MockContainerRegistryServiceInterfaceDeleteRegistryRepositoryTagCall{Call: call}
}

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

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

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

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

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

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

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

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

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

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

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

// GetRegistryRepositoryTagDetail indicates an expected call of GetRegistryRepositoryTagDetail.
func (mr *MockContainerRegistryServiceInterfaceMockRecorder) GetRegistryRepositoryTagDetail(pid, repository, tagName any, options ...any) *MockContainerRegistryServiceInterfaceGetRegistryRepositoryTagDetailCall {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{pid, repository, tagName}, options...)
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetRegistryRepositoryTagDetail", reflect.TypeOf((*MockContainerRegistryServiceInterface)(nil).GetRegistryRepositoryTagDetail), varargs...)
	return &MockContainerRegistryServiceInterfaceGetRegistryRepositoryTagDetailCall{Call: call}
}

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

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

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

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

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

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

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

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

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

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

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

// ListGroupRegistryRepositories indicates an expected call of ListGroupRegistryRepositories.
func (mr *MockContainerRegistryServiceInterfaceMockRecorder) ListGroupRegistryRepositories(gid, opt any, options ...any) *MockContainerRegistryServiceInterfaceListGroupRegistryRepositoriesCall {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{gid, opt}, options...)
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListGroupRegistryRepositories", reflect.TypeOf((*MockContainerRegistryServiceInterface)(nil).ListGroupRegistryRepositories), varargs...)
	return &MockContainerRegistryServiceInterfaceListGroupRegistryRepositoriesCall{Call: call}
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

// Do rewrite *gomock.Call.Do
func (c *MockContainerRegistryServiceInterfaceListRegistryRepositoryTagsCall) Do(f func(any, int64, *gitlab.ListRegistryRepositoryTagsOptions, ...gitlab.RequestOptionFunc) ([]*gitlab.RegistryRepositoryTag, *gitlab.Response, error)) *MockContainerRegistryServiceInterfaceListRegistryRepositoryTagsCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockContainerRegistryServiceInterfaceListRegistryRepositoryTagsCall) DoAndReturn(f func(any, int64, *gitlab.ListRegistryRepositoryTagsOptions, ...gitlab.RequestOptionFunc) ([]*gitlab.RegistryRepositoryTag, *gitlab.Response, error)) *MockContainerRegistryServiceInterfaceListRegistryRepositoryTagsCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}
