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

package testing

import (
	reflect "reflect"

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

// MockProtectedTagsServiceInterface is a mock of ProtectedTagsServiceInterface interface.
type MockProtectedTagsServiceInterface struct {
	ctrl     *gomock.Controller
	recorder *MockProtectedTagsServiceInterfaceMockRecorder
	isgomock struct{}
}

// MockProtectedTagsServiceInterfaceMockRecorder is the mock recorder for MockProtectedTagsServiceInterface.
type MockProtectedTagsServiceInterfaceMockRecorder struct {
	mock *MockProtectedTagsServiceInterface
}

// NewMockProtectedTagsServiceInterface creates a new mock instance.
func NewMockProtectedTagsServiceInterface(ctrl *gomock.Controller) *MockProtectedTagsServiceInterface {
	mock := &MockProtectedTagsServiceInterface{ctrl: ctrl}
	mock.recorder = &MockProtectedTagsServiceInterfaceMockRecorder{mock}
	return mock
}

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

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

// GetProtectedTag indicates an expected call of GetProtectedTag.
func (mr *MockProtectedTagsServiceInterfaceMockRecorder) GetProtectedTag(pid, tag any, options ...any) *MockProtectedTagsServiceInterfaceGetProtectedTagCall {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{pid, tag}, options...)
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetProtectedTag", reflect.TypeOf((*MockProtectedTagsServiceInterface)(nil).GetProtectedTag), varargs...)
	return &MockProtectedTagsServiceInterfaceGetProtectedTagCall{Call: call}
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

// UnprotectRepositoryTags indicates an expected call of UnprotectRepositoryTags.
func (mr *MockProtectedTagsServiceInterfaceMockRecorder) UnprotectRepositoryTags(pid, tag any, options ...any) *MockProtectedTagsServiceInterfaceUnprotectRepositoryTagsCall {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{pid, tag}, options...)
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UnprotectRepositoryTags", reflect.TypeOf((*MockProtectedTagsServiceInterface)(nil).UnprotectRepositoryTags), varargs...)
	return &MockProtectedTagsServiceInterfaceUnprotectRepositoryTagsCall{Call: call}
}

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

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

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

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