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

package testing

import (
	reflect "reflect"

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

// MockPipelineSchedulesServiceInterface is a mock of PipelineSchedulesServiceInterface interface.
type MockPipelineSchedulesServiceInterface struct {
	ctrl     *gomock.Controller
	recorder *MockPipelineSchedulesServiceInterfaceMockRecorder
	isgomock struct{}
}

// MockPipelineSchedulesServiceInterfaceMockRecorder is the mock recorder for MockPipelineSchedulesServiceInterface.
type MockPipelineSchedulesServiceInterfaceMockRecorder struct {
	mock *MockPipelineSchedulesServiceInterface
}

// NewMockPipelineSchedulesServiceInterface creates a new mock instance.
func NewMockPipelineSchedulesServiceInterface(ctrl *gomock.Controller) *MockPipelineSchedulesServiceInterface {
	mock := &MockPipelineSchedulesServiceInterface{ctrl: ctrl}
	mock.recorder = &MockPipelineSchedulesServiceInterfaceMockRecorder{mock}
	return mock
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

// DeletePipelineSchedule indicates an expected call of DeletePipelineSchedule.
func (mr *MockPipelineSchedulesServiceInterfaceMockRecorder) DeletePipelineSchedule(pid, schedule any, options ...any) *MockPipelineSchedulesServiceInterfaceDeletePipelineScheduleCall {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{pid, schedule}, options...)
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeletePipelineSchedule", reflect.TypeOf((*MockPipelineSchedulesServiceInterface)(nil).DeletePipelineSchedule), varargs...)
	return &MockPipelineSchedulesServiceInterfaceDeletePipelineScheduleCall{Call: call}
}

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

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

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

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

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

// DeletePipelineScheduleVariable indicates an expected call of DeletePipelineScheduleVariable.
func (mr *MockPipelineSchedulesServiceInterfaceMockRecorder) DeletePipelineScheduleVariable(pid, schedule, key any, options ...any) *MockPipelineSchedulesServiceInterfaceDeletePipelineScheduleVariableCall {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{pid, schedule, key}, options...)
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeletePipelineScheduleVariable", reflect.TypeOf((*MockPipelineSchedulesServiceInterface)(nil).DeletePipelineScheduleVariable), varargs...)
	return &MockPipelineSchedulesServiceInterfaceDeletePipelineScheduleVariableCall{Call: call}
}

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

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

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

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

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

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

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

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

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

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

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

// EditPipelineScheduleVariable indicates an expected call of EditPipelineScheduleVariable.
func (mr *MockPipelineSchedulesServiceInterfaceMockRecorder) EditPipelineScheduleVariable(pid, schedule, key, opt any, options ...any) *MockPipelineSchedulesServiceInterfaceEditPipelineScheduleVariableCall {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{pid, schedule, key, opt}, options...)
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EditPipelineScheduleVariable", reflect.TypeOf((*MockPipelineSchedulesServiceInterface)(nil).EditPipelineScheduleVariable), varargs...)
	return &MockPipelineSchedulesServiceInterfaceEditPipelineScheduleVariableCall{Call: call}
}

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

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

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

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

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

// GetPipelineSchedule indicates an expected call of GetPipelineSchedule.
func (mr *MockPipelineSchedulesServiceInterfaceMockRecorder) GetPipelineSchedule(pid, schedule any, options ...any) *MockPipelineSchedulesServiceInterfaceGetPipelineScheduleCall {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{pid, schedule}, options...)
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetPipelineSchedule", reflect.TypeOf((*MockPipelineSchedulesServiceInterface)(nil).GetPipelineSchedule), varargs...)
	return &MockPipelineSchedulesServiceInterfaceGetPipelineScheduleCall{Call: call}
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

// RunPipelineSchedule indicates an expected call of RunPipelineSchedule.
func (mr *MockPipelineSchedulesServiceInterfaceMockRecorder) RunPipelineSchedule(pid, schedule any, options ...any) *MockPipelineSchedulesServiceInterfaceRunPipelineScheduleCall {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{pid, schedule}, options...)
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RunPipelineSchedule", reflect.TypeOf((*MockPipelineSchedulesServiceInterface)(nil).RunPipelineSchedule), varargs...)
	return &MockPipelineSchedulesServiceInterfaceRunPipelineScheduleCall{Call: call}
}

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

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

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

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

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

// TakeOwnershipOfPipelineSchedule indicates an expected call of TakeOwnershipOfPipelineSchedule.
func (mr *MockPipelineSchedulesServiceInterfaceMockRecorder) TakeOwnershipOfPipelineSchedule(pid, schedule any, options ...any) *MockPipelineSchedulesServiceInterfaceTakeOwnershipOfPipelineScheduleCall {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{pid, schedule}, options...)
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TakeOwnershipOfPipelineSchedule", reflect.TypeOf((*MockPipelineSchedulesServiceInterface)(nil).TakeOwnershipOfPipelineSchedule), varargs...)
	return &MockPipelineSchedulesServiceInterfaceTakeOwnershipOfPipelineScheduleCall{Call: call}
}

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

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

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

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