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

// 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"
)

// MockProjectFeatureFlagServiceInterface is a mock of ProjectFeatureFlagServiceInterface interface.
type MockProjectFeatureFlagServiceInterface struct {
	ctrl     *gomock.Controller
	recorder *MockProjectFeatureFlagServiceInterfaceMockRecorder
	isgomock struct{}
}

// MockProjectFeatureFlagServiceInterfaceMockRecorder is the mock recorder for MockProjectFeatureFlagServiceInterface.
type MockProjectFeatureFlagServiceInterfaceMockRecorder struct {
	mock *MockProjectFeatureFlagServiceInterface
}

// NewMockProjectFeatureFlagServiceInterface creates a new mock instance.
func NewMockProjectFeatureFlagServiceInterface(ctrl *gomock.Controller) *MockProjectFeatureFlagServiceInterface {
	mock := &MockProjectFeatureFlagServiceInterface{ctrl: ctrl}
	mock.recorder = &MockProjectFeatureFlagServiceInterfaceMockRecorder{mock}
	return mock
}

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

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

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

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

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

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

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

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

// DeleteProjectFeatureFlag indicates an expected call of DeleteProjectFeatureFlag.
func (mr *MockProjectFeatureFlagServiceInterfaceMockRecorder) DeleteProjectFeatureFlag(pid, name any, options ...any) *MockProjectFeatureFlagServiceInterfaceDeleteProjectFeatureFlagCall {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{pid, name}, options...)
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteProjectFeatureFlag", reflect.TypeOf((*MockProjectFeatureFlagServiceInterface)(nil).DeleteProjectFeatureFlag), varargs...)
	return &MockProjectFeatureFlagServiceInterfaceDeleteProjectFeatureFlagCall{Call: call}
}

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

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

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

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

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

// GetProjectFeatureFlag indicates an expected call of GetProjectFeatureFlag.
func (mr *MockProjectFeatureFlagServiceInterfaceMockRecorder) GetProjectFeatureFlag(pid, name any, options ...any) *MockProjectFeatureFlagServiceInterfaceGetProjectFeatureFlagCall {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{pid, name}, options...)
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetProjectFeatureFlag", reflect.TypeOf((*MockProjectFeatureFlagServiceInterface)(nil).GetProjectFeatureFlag), varargs...)
	return &MockProjectFeatureFlagServiceInterfaceGetProjectFeatureFlagCall{Call: call}
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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