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

package testing

import (
	reflect "reflect"

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

// MockDeployKeysServiceInterface is a mock of DeployKeysServiceInterface interface.
type MockDeployKeysServiceInterface struct {
	ctrl     *gomock.Controller
	recorder *MockDeployKeysServiceInterfaceMockRecorder
	isgomock struct{}
}

// MockDeployKeysServiceInterfaceMockRecorder is the mock recorder for MockDeployKeysServiceInterface.
type MockDeployKeysServiceInterfaceMockRecorder struct {
	mock *MockDeployKeysServiceInterface
}

// NewMockDeployKeysServiceInterface creates a new mock instance.
func NewMockDeployKeysServiceInterface(ctrl *gomock.Controller) *MockDeployKeysServiceInterface {
	mock := &MockDeployKeysServiceInterface{ctrl: ctrl}
	mock.recorder = &MockDeployKeysServiceInterfaceMockRecorder{mock}
	return mock
}

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

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

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

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

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

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

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

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

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

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

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

// Do rewrite *gomock.Call.Do
func (c *MockDeployKeysServiceInterfaceAddInstanceDeployKeyCall) Do(f func(*gitlab.AddInstanceDeployKeyOptions, ...gitlab.RequestOptionFunc) (*gitlab.InstanceDeployKey, *gitlab.Response, error)) *MockDeployKeysServiceInterfaceAddInstanceDeployKeyCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockDeployKeysServiceInterfaceAddInstanceDeployKeyCall) DoAndReturn(f func(*gitlab.AddInstanceDeployKeyOptions, ...gitlab.RequestOptionFunc) (*gitlab.InstanceDeployKey, *gitlab.Response, error)) *MockDeployKeysServiceInterfaceAddInstanceDeployKeyCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

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

// DeleteDeployKey indicates an expected call of DeleteDeployKey.
func (mr *MockDeployKeysServiceInterfaceMockRecorder) DeleteDeployKey(pid, deployKey any, options ...any) *MockDeployKeysServiceInterfaceDeleteDeployKeyCall {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{pid, deployKey}, options...)
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteDeployKey", reflect.TypeOf((*MockDeployKeysServiceInterface)(nil).DeleteDeployKey), varargs...)
	return &MockDeployKeysServiceInterfaceDeleteDeployKeyCall{Call: call}
}

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

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

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

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

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

// EnableDeployKey indicates an expected call of EnableDeployKey.
func (mr *MockDeployKeysServiceInterfaceMockRecorder) EnableDeployKey(pid, deployKey any, options ...any) *MockDeployKeysServiceInterfaceEnableDeployKeyCall {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{pid, deployKey}, options...)
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EnableDeployKey", reflect.TypeOf((*MockDeployKeysServiceInterface)(nil).EnableDeployKey), varargs...)
	return &MockDeployKeysServiceInterfaceEnableDeployKeyCall{Call: call}
}

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

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

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

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

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

// GetDeployKey indicates an expected call of GetDeployKey.
func (mr *MockDeployKeysServiceInterfaceMockRecorder) GetDeployKey(pid, deployKey any, options ...any) *MockDeployKeysServiceInterfaceGetDeployKeyCall {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{pid, deployKey}, options...)
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetDeployKey", reflect.TypeOf((*MockDeployKeysServiceInterface)(nil).GetDeployKey), varargs...)
	return &MockDeployKeysServiceInterfaceGetDeployKeyCall{Call: call}
}

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

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

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

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

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

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

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

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

// Do rewrite *gomock.Call.Do
func (c *MockDeployKeysServiceInterfaceListAllDeployKeysCall) Do(f func(*gitlab.ListInstanceDeployKeysOptions, ...gitlab.RequestOptionFunc) ([]*gitlab.InstanceDeployKey, *gitlab.Response, error)) *MockDeployKeysServiceInterfaceListAllDeployKeysCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockDeployKeysServiceInterfaceListAllDeployKeysCall) DoAndReturn(f func(*gitlab.ListInstanceDeployKeysOptions, ...gitlab.RequestOptionFunc) ([]*gitlab.InstanceDeployKey, *gitlab.Response, error)) *MockDeployKeysServiceInterfaceListAllDeployKeysCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

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

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

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

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

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

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

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

// ListUserProjectDeployKeys indicates an expected call of ListUserProjectDeployKeys.
func (mr *MockDeployKeysServiceInterfaceMockRecorder) ListUserProjectDeployKeys(uid, opt any, options ...any) *MockDeployKeysServiceInterfaceListUserProjectDeployKeysCall {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{uid, opt}, options...)
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListUserProjectDeployKeys", reflect.TypeOf((*MockDeployKeysServiceInterface)(nil).ListUserProjectDeployKeys), varargs...)
	return &MockDeployKeysServiceInterfaceListUserProjectDeployKeysCall{Call: call}
}

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

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

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

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

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

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

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

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

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

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