// Code generated by MockGen. DO NOT EDIT.
// Source: service.go

// Package mocks is a generated GoMock package.
package mocks

import (
	context "context"
	reflect "reflect"

	models "d7y.io/dragonfly/v2/manager/models"
	rbac "d7y.io/dragonfly/v2/manager/permission/rbac"
	types "d7y.io/dragonfly/v2/manager/types"
	objectstorage "d7y.io/dragonfly/v2/pkg/objectstorage"
	gin "github.com/gin-gonic/gin"
	gomock "github.com/golang/mock/gomock"
)

// MockService is a mock of Service interface.
type MockService struct {
	ctrl     *gomock.Controller
	recorder *MockServiceMockRecorder
}

// MockServiceMockRecorder is the mock recorder for MockService.
type MockServiceMockRecorder struct {
	mock *MockService
}

// NewMockService creates a new mock instance.
func NewMockService(ctrl *gomock.Controller) *MockService {
	mock := &MockService{ctrl: ctrl}
	mock.recorder = &MockServiceMockRecorder{mock}
	return mock
}

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

// AddPermissionForRole mocks base method.
func (m *MockService) AddPermissionForRole(arg0 context.Context, arg1 string, arg2 types.AddPermissionForRoleRequest) (bool, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AddPermissionForRole", arg0, arg1, arg2)
	ret0, _ := ret[0].(bool)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// AddPermissionForRole indicates an expected call of AddPermissionForRole.
func (mr *MockServiceMockRecorder) AddPermissionForRole(arg0, arg1, arg2 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddPermissionForRole", reflect.TypeOf((*MockService)(nil).AddPermissionForRole), arg0, arg1, arg2)
}

// AddRoleForUser mocks base method.
func (m *MockService) AddRoleForUser(arg0 context.Context, arg1 types.AddRoleForUserParams) (bool, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AddRoleForUser", arg0, arg1)
	ret0, _ := ret[0].(bool)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// AddRoleForUser indicates an expected call of AddRoleForUser.
func (mr *MockServiceMockRecorder) AddRoleForUser(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddRoleForUser", reflect.TypeOf((*MockService)(nil).AddRoleForUser), arg0, arg1)
}

// AddSchedulerClusterToSeedPeerCluster mocks base method.
func (m *MockService) AddSchedulerClusterToSeedPeerCluster(arg0 context.Context, arg1, arg2 uint) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AddSchedulerClusterToSeedPeerCluster", arg0, arg1, arg2)
	ret0, _ := ret[0].(error)
	return ret0
}

// AddSchedulerClusterToSeedPeerCluster indicates an expected call of AddSchedulerClusterToSeedPeerCluster.
func (mr *MockServiceMockRecorder) AddSchedulerClusterToSeedPeerCluster(arg0, arg1, arg2 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddSchedulerClusterToSeedPeerCluster", reflect.TypeOf((*MockService)(nil).AddSchedulerClusterToSeedPeerCluster), arg0, arg1, arg2)
}

// AddSchedulerToSchedulerCluster mocks base method.
func (m *MockService) AddSchedulerToSchedulerCluster(arg0 context.Context, arg1, arg2 uint) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AddSchedulerToSchedulerCluster", arg0, arg1, arg2)
	ret0, _ := ret[0].(error)
	return ret0
}

// AddSchedulerToSchedulerCluster indicates an expected call of AddSchedulerToSchedulerCluster.
func (mr *MockServiceMockRecorder) AddSchedulerToSchedulerCluster(arg0, arg1, arg2 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddSchedulerToSchedulerCluster", reflect.TypeOf((*MockService)(nil).AddSchedulerToSchedulerCluster), arg0, arg1, arg2)
}

// AddSeedPeerToSeedPeerCluster mocks base method.
func (m *MockService) AddSeedPeerToSeedPeerCluster(arg0 context.Context, arg1, arg2 uint) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AddSeedPeerToSeedPeerCluster", arg0, arg1, arg2)
	ret0, _ := ret[0].(error)
	return ret0
}

// AddSeedPeerToSeedPeerCluster indicates an expected call of AddSeedPeerToSeedPeerCluster.
func (mr *MockServiceMockRecorder) AddSeedPeerToSeedPeerCluster(arg0, arg1, arg2 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddSeedPeerToSeedPeerCluster", reflect.TypeOf((*MockService)(nil).AddSeedPeerToSeedPeerCluster), arg0, arg1, arg2)
}

// CreateApplication mocks base method.
func (m *MockService) CreateApplication(arg0 context.Context, arg1 types.CreateApplicationRequest) (*models.Application, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateApplication", arg0, arg1)
	ret0, _ := ret[0].(*models.Application)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CreateApplication indicates an expected call of CreateApplication.
func (mr *MockServiceMockRecorder) CreateApplication(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateApplication", reflect.TypeOf((*MockService)(nil).CreateApplication), arg0, arg1)
}

// CreateBucket mocks base method.
func (m *MockService) CreateBucket(arg0 context.Context, arg1 types.CreateBucketRequest) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateBucket", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// CreateBucket indicates an expected call of CreateBucket.
func (mr *MockServiceMockRecorder) CreateBucket(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateBucket", reflect.TypeOf((*MockService)(nil).CreateBucket), arg0, arg1)
}

// CreateCluster mocks base method.
func (m *MockService) CreateCluster(arg0 context.Context, arg1 types.CreateClusterRequest) (*types.CreateClusterResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateCluster", arg0, arg1)
	ret0, _ := ret[0].(*types.CreateClusterResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CreateCluster indicates an expected call of CreateCluster.
func (mr *MockServiceMockRecorder) CreateCluster(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateCluster", reflect.TypeOf((*MockService)(nil).CreateCluster), arg0, arg1)
}

// CreateConfig mocks base method.
func (m *MockService) CreateConfig(arg0 context.Context, arg1 types.CreateConfigRequest) (*models.Config, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateConfig", arg0, arg1)
	ret0, _ := ret[0].(*models.Config)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CreateConfig indicates an expected call of CreateConfig.
func (mr *MockServiceMockRecorder) CreateConfig(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateConfig", reflect.TypeOf((*MockService)(nil).CreateConfig), arg0, arg1)
}

// CreateOauth mocks base method.
func (m *MockService) CreateOauth(arg0 context.Context, arg1 types.CreateOauthRequest) (*models.Oauth, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateOauth", arg0, arg1)
	ret0, _ := ret[0].(*models.Oauth)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CreateOauth indicates an expected call of CreateOauth.
func (mr *MockServiceMockRecorder) CreateOauth(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateOauth", reflect.TypeOf((*MockService)(nil).CreateOauth), arg0, arg1)
}

// CreatePersonalAccessToken mocks base method.
func (m *MockService) CreatePersonalAccessToken(arg0 context.Context, arg1 types.CreatePersonalAccessTokenRequest) (*models.PersonalAccessToken, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreatePersonalAccessToken", arg0, arg1)
	ret0, _ := ret[0].(*models.PersonalAccessToken)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CreatePersonalAccessToken indicates an expected call of CreatePersonalAccessToken.
func (mr *MockServiceMockRecorder) CreatePersonalAccessToken(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreatePersonalAccessToken", reflect.TypeOf((*MockService)(nil).CreatePersonalAccessToken), arg0, arg1)
}

// CreatePreheatJob mocks base method.
func (m *MockService) CreatePreheatJob(arg0 context.Context, arg1 types.CreatePreheatJobRequest) (*models.Job, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreatePreheatJob", arg0, arg1)
	ret0, _ := ret[0].(*models.Job)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CreatePreheatJob indicates an expected call of CreatePreheatJob.
func (mr *MockServiceMockRecorder) CreatePreheatJob(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreatePreheatJob", reflect.TypeOf((*MockService)(nil).CreatePreheatJob), arg0, arg1)
}

// CreateRole mocks base method.
func (m *MockService) CreateRole(arg0 context.Context, arg1 types.CreateRoleRequest) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateRole", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// CreateRole indicates an expected call of CreateRole.
func (mr *MockServiceMockRecorder) CreateRole(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateRole", reflect.TypeOf((*MockService)(nil).CreateRole), arg0, arg1)
}

// CreateScheduler mocks base method.
func (m *MockService) CreateScheduler(arg0 context.Context, arg1 types.CreateSchedulerRequest) (*models.Scheduler, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateScheduler", arg0, arg1)
	ret0, _ := ret[0].(*models.Scheduler)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CreateScheduler indicates an expected call of CreateScheduler.
func (mr *MockServiceMockRecorder) CreateScheduler(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateScheduler", reflect.TypeOf((*MockService)(nil).CreateScheduler), arg0, arg1)
}

// CreateSchedulerCluster mocks base method.
func (m *MockService) CreateSchedulerCluster(arg0 context.Context, arg1 types.CreateSchedulerClusterRequest) (*models.SchedulerCluster, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateSchedulerCluster", arg0, arg1)
	ret0, _ := ret[0].(*models.SchedulerCluster)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CreateSchedulerCluster indicates an expected call of CreateSchedulerCluster.
func (mr *MockServiceMockRecorder) CreateSchedulerCluster(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateSchedulerCluster", reflect.TypeOf((*MockService)(nil).CreateSchedulerCluster), arg0, arg1)
}

// CreateSeedPeer mocks base method.
func (m *MockService) CreateSeedPeer(arg0 context.Context, arg1 types.CreateSeedPeerRequest) (*models.SeedPeer, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateSeedPeer", arg0, arg1)
	ret0, _ := ret[0].(*models.SeedPeer)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CreateSeedPeer indicates an expected call of CreateSeedPeer.
func (mr *MockServiceMockRecorder) CreateSeedPeer(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateSeedPeer", reflect.TypeOf((*MockService)(nil).CreateSeedPeer), arg0, arg1)
}

// CreateSeedPeerCluster mocks base method.
func (m *MockService) CreateSeedPeerCluster(arg0 context.Context, arg1 types.CreateSeedPeerClusterRequest) (*models.SeedPeerCluster, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateSeedPeerCluster", arg0, arg1)
	ret0, _ := ret[0].(*models.SeedPeerCluster)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CreateSeedPeerCluster indicates an expected call of CreateSeedPeerCluster.
func (mr *MockServiceMockRecorder) CreateSeedPeerCluster(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateSeedPeerCluster", reflect.TypeOf((*MockService)(nil).CreateSeedPeerCluster), arg0, arg1)
}

// CreateV1Preheat mocks base method.
func (m *MockService) CreateV1Preheat(arg0 context.Context, arg1 types.CreateV1PreheatRequest) (*types.CreateV1PreheatResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateV1Preheat", arg0, arg1)
	ret0, _ := ret[0].(*types.CreateV1PreheatResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CreateV1Preheat indicates an expected call of CreateV1Preheat.
func (mr *MockServiceMockRecorder) CreateV1Preheat(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateV1Preheat", reflect.TypeOf((*MockService)(nil).CreateV1Preheat), arg0, arg1)
}

// DeletePermissionForRole mocks base method.
func (m *MockService) DeletePermissionForRole(arg0 context.Context, arg1 string, arg2 types.DeletePermissionForRoleRequest) (bool, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeletePermissionForRole", arg0, arg1, arg2)
	ret0, _ := ret[0].(bool)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DeletePermissionForRole indicates an expected call of DeletePermissionForRole.
func (mr *MockServiceMockRecorder) DeletePermissionForRole(arg0, arg1, arg2 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeletePermissionForRole", reflect.TypeOf((*MockService)(nil).DeletePermissionForRole), arg0, arg1, arg2)
}

// DeleteRoleForUser mocks base method.
func (m *MockService) DeleteRoleForUser(arg0 context.Context, arg1 types.DeleteRoleForUserParams) (bool, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteRoleForUser", arg0, arg1)
	ret0, _ := ret[0].(bool)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DeleteRoleForUser indicates an expected call of DeleteRoleForUser.
func (mr *MockServiceMockRecorder) DeleteRoleForUser(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteRoleForUser", reflect.TypeOf((*MockService)(nil).DeleteRoleForUser), arg0, arg1)
}

// DestroyApplication mocks base method.
func (m *MockService) DestroyApplication(arg0 context.Context, arg1 uint) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DestroyApplication", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// DestroyApplication indicates an expected call of DestroyApplication.
func (mr *MockServiceMockRecorder) DestroyApplication(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DestroyApplication", reflect.TypeOf((*MockService)(nil).DestroyApplication), arg0, arg1)
}

// DestroyBucket mocks base method.
func (m *MockService) DestroyBucket(arg0 context.Context, arg1 string) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DestroyBucket", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// DestroyBucket indicates an expected call of DestroyBucket.
func (mr *MockServiceMockRecorder) DestroyBucket(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DestroyBucket", reflect.TypeOf((*MockService)(nil).DestroyBucket), arg0, arg1)
}

// DestroyCluster mocks base method.
func (m *MockService) DestroyCluster(arg0 context.Context, arg1 uint) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DestroyCluster", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// DestroyCluster indicates an expected call of DestroyCluster.
func (mr *MockServiceMockRecorder) DestroyCluster(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DestroyCluster", reflect.TypeOf((*MockService)(nil).DestroyCluster), arg0, arg1)
}

// DestroyConfig mocks base method.
func (m *MockService) DestroyConfig(arg0 context.Context, arg1 uint) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DestroyConfig", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// DestroyConfig indicates an expected call of DestroyConfig.
func (mr *MockServiceMockRecorder) DestroyConfig(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DestroyConfig", reflect.TypeOf((*MockService)(nil).DestroyConfig), arg0, arg1)
}

// DestroyJob mocks base method.
func (m *MockService) DestroyJob(arg0 context.Context, arg1 uint) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DestroyJob", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// DestroyJob indicates an expected call of DestroyJob.
func (mr *MockServiceMockRecorder) DestroyJob(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DestroyJob", reflect.TypeOf((*MockService)(nil).DestroyJob), arg0, arg1)
}

// DestroyModel mocks base method.
func (m *MockService) DestroyModel(arg0 context.Context, arg1 uint) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DestroyModel", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// DestroyModel indicates an expected call of DestroyModel.
func (mr *MockServiceMockRecorder) DestroyModel(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DestroyModel", reflect.TypeOf((*MockService)(nil).DestroyModel), arg0, arg1)
}

// DestroyOauth mocks base method.
func (m *MockService) DestroyOauth(arg0 context.Context, arg1 uint) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DestroyOauth", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// DestroyOauth indicates an expected call of DestroyOauth.
func (mr *MockServiceMockRecorder) DestroyOauth(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DestroyOauth", reflect.TypeOf((*MockService)(nil).DestroyOauth), arg0, arg1)
}

// DestroyPeer mocks base method.
func (m *MockService) DestroyPeer(arg0 context.Context, arg1 uint) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DestroyPeer", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// DestroyPeer indicates an expected call of DestroyPeer.
func (mr *MockServiceMockRecorder) DestroyPeer(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DestroyPeer", reflect.TypeOf((*MockService)(nil).DestroyPeer), arg0, arg1)
}

// DestroyPersonalAccessToken mocks base method.
func (m *MockService) DestroyPersonalAccessToken(arg0 context.Context, arg1 uint) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DestroyPersonalAccessToken", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// DestroyPersonalAccessToken indicates an expected call of DestroyPersonalAccessToken.
func (mr *MockServiceMockRecorder) DestroyPersonalAccessToken(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DestroyPersonalAccessToken", reflect.TypeOf((*MockService)(nil).DestroyPersonalAccessToken), arg0, arg1)
}

// DestroyRole mocks base method.
func (m *MockService) DestroyRole(arg0 context.Context, arg1 string) (bool, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DestroyRole", arg0, arg1)
	ret0, _ := ret[0].(bool)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DestroyRole indicates an expected call of DestroyRole.
func (mr *MockServiceMockRecorder) DestroyRole(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DestroyRole", reflect.TypeOf((*MockService)(nil).DestroyRole), arg0, arg1)
}

// DestroyScheduler mocks base method.
func (m *MockService) DestroyScheduler(arg0 context.Context, arg1 uint) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DestroyScheduler", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// DestroyScheduler indicates an expected call of DestroyScheduler.
func (mr *MockServiceMockRecorder) DestroyScheduler(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DestroyScheduler", reflect.TypeOf((*MockService)(nil).DestroyScheduler), arg0, arg1)
}

// DestroySchedulerCluster mocks base method.
func (m *MockService) DestroySchedulerCluster(arg0 context.Context, arg1 uint) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DestroySchedulerCluster", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// DestroySchedulerCluster indicates an expected call of DestroySchedulerCluster.
func (mr *MockServiceMockRecorder) DestroySchedulerCluster(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DestroySchedulerCluster", reflect.TypeOf((*MockService)(nil).DestroySchedulerCluster), arg0, arg1)
}

// DestroySeedPeer mocks base method.
func (m *MockService) DestroySeedPeer(arg0 context.Context, arg1 uint) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DestroySeedPeer", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// DestroySeedPeer indicates an expected call of DestroySeedPeer.
func (mr *MockServiceMockRecorder) DestroySeedPeer(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DestroySeedPeer", reflect.TypeOf((*MockService)(nil).DestroySeedPeer), arg0, arg1)
}

// DestroySeedPeerCluster mocks base method.
func (m *MockService) DestroySeedPeerCluster(arg0 context.Context, arg1 uint) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DestroySeedPeerCluster", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// DestroySeedPeerCluster indicates an expected call of DestroySeedPeerCluster.
func (mr *MockServiceMockRecorder) DestroySeedPeerCluster(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DestroySeedPeerCluster", reflect.TypeOf((*MockService)(nil).DestroySeedPeerCluster), arg0, arg1)
}

// GetApplication mocks base method.
func (m *MockService) GetApplication(arg0 context.Context, arg1 uint) (*models.Application, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetApplication", arg0, arg1)
	ret0, _ := ret[0].(*models.Application)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetApplication indicates an expected call of GetApplication.
func (mr *MockServiceMockRecorder) GetApplication(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetApplication", reflect.TypeOf((*MockService)(nil).GetApplication), arg0, arg1)
}

// GetApplications mocks base method.
func (m *MockService) GetApplications(arg0 context.Context, arg1 types.GetApplicationsQuery) ([]models.Application, int64, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetApplications", arg0, arg1)
	ret0, _ := ret[0].([]models.Application)
	ret1, _ := ret[1].(int64)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// GetApplications indicates an expected call of GetApplications.
func (mr *MockServiceMockRecorder) GetApplications(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetApplications", reflect.TypeOf((*MockService)(nil).GetApplications), arg0, arg1)
}

// GetBucket mocks base method.
func (m *MockService) GetBucket(arg0 context.Context, arg1 string) (*objectstorage.BucketMetadata, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetBucket", arg0, arg1)
	ret0, _ := ret[0].(*objectstorage.BucketMetadata)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetBucket indicates an expected call of GetBucket.
func (mr *MockServiceMockRecorder) GetBucket(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetBucket", reflect.TypeOf((*MockService)(nil).GetBucket), arg0, arg1)
}

// GetBuckets mocks base method.
func (m *MockService) GetBuckets(arg0 context.Context) ([]*objectstorage.BucketMetadata, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetBuckets", arg0)
	ret0, _ := ret[0].([]*objectstorage.BucketMetadata)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetBuckets indicates an expected call of GetBuckets.
func (mr *MockServiceMockRecorder) GetBuckets(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetBuckets", reflect.TypeOf((*MockService)(nil).GetBuckets), arg0)
}

// GetCluster mocks base method.
func (m *MockService) GetCluster(arg0 context.Context, arg1 uint) (*types.GetClusterResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetCluster", arg0, arg1)
	ret0, _ := ret[0].(*types.GetClusterResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetCluster indicates an expected call of GetCluster.
func (mr *MockServiceMockRecorder) GetCluster(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetCluster", reflect.TypeOf((*MockService)(nil).GetCluster), arg0, arg1)
}

// GetClusters mocks base method.
func (m *MockService) GetClusters(arg0 context.Context, arg1 types.GetClustersQuery) ([]types.GetClusterResponse, int64, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetClusters", arg0, arg1)
	ret0, _ := ret[0].([]types.GetClusterResponse)
	ret1, _ := ret[1].(int64)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// GetClusters indicates an expected call of GetClusters.
func (mr *MockServiceMockRecorder) GetClusters(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetClusters", reflect.TypeOf((*MockService)(nil).GetClusters), arg0, arg1)
}

// GetConfig mocks base method.
func (m *MockService) GetConfig(arg0 context.Context, arg1 uint) (*models.Config, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetConfig", arg0, arg1)
	ret0, _ := ret[0].(*models.Config)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetConfig indicates an expected call of GetConfig.
func (mr *MockServiceMockRecorder) GetConfig(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetConfig", reflect.TypeOf((*MockService)(nil).GetConfig), arg0, arg1)
}

// GetConfigs mocks base method.
func (m *MockService) GetConfigs(arg0 context.Context, arg1 types.GetConfigsQuery) ([]models.Config, int64, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetConfigs", arg0, arg1)
	ret0, _ := ret[0].([]models.Config)
	ret1, _ := ret[1].(int64)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// GetConfigs indicates an expected call of GetConfigs.
func (mr *MockServiceMockRecorder) GetConfigs(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetConfigs", reflect.TypeOf((*MockService)(nil).GetConfigs), arg0, arg1)
}

// GetJob mocks base method.
func (m *MockService) GetJob(arg0 context.Context, arg1 uint) (*models.Job, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetJob", arg0, arg1)
	ret0, _ := ret[0].(*models.Job)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetJob indicates an expected call of GetJob.
func (mr *MockServiceMockRecorder) GetJob(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetJob", reflect.TypeOf((*MockService)(nil).GetJob), arg0, arg1)
}

// GetJobs mocks base method.
func (m *MockService) GetJobs(arg0 context.Context, arg1 types.GetJobsQuery) ([]models.Job, int64, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetJobs", arg0, arg1)
	ret0, _ := ret[0].([]models.Job)
	ret1, _ := ret[1].(int64)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// GetJobs indicates an expected call of GetJobs.
func (mr *MockServiceMockRecorder) GetJobs(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetJobs", reflect.TypeOf((*MockService)(nil).GetJobs), arg0, arg1)
}

// GetModel mocks base method.
func (m *MockService) GetModel(arg0 context.Context, arg1 uint) (*models.Model, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetModel", arg0, arg1)
	ret0, _ := ret[0].(*models.Model)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetModel indicates an expected call of GetModel.
func (mr *MockServiceMockRecorder) GetModel(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetModel", reflect.TypeOf((*MockService)(nil).GetModel), arg0, arg1)
}

// GetModels mocks base method.
func (m *MockService) GetModels(arg0 context.Context, arg1 types.GetModelsQuery) ([]models.Model, int64, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetModels", arg0, arg1)
	ret0, _ := ret[0].([]models.Model)
	ret1, _ := ret[1].(int64)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// GetModels indicates an expected call of GetModels.
func (mr *MockServiceMockRecorder) GetModels(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetModels", reflect.TypeOf((*MockService)(nil).GetModels), arg0, arg1)
}

// GetOauth mocks base method.
func (m *MockService) GetOauth(arg0 context.Context, arg1 uint) (*models.Oauth, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetOauth", arg0, arg1)
	ret0, _ := ret[0].(*models.Oauth)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetOauth indicates an expected call of GetOauth.
func (mr *MockServiceMockRecorder) GetOauth(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetOauth", reflect.TypeOf((*MockService)(nil).GetOauth), arg0, arg1)
}

// GetOauths mocks base method.
func (m *MockService) GetOauths(arg0 context.Context, arg1 types.GetOauthsQuery) ([]models.Oauth, int64, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetOauths", arg0, arg1)
	ret0, _ := ret[0].([]models.Oauth)
	ret1, _ := ret[1].(int64)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// GetOauths indicates an expected call of GetOauths.
func (mr *MockServiceMockRecorder) GetOauths(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetOauths", reflect.TypeOf((*MockService)(nil).GetOauths), arg0, arg1)
}

// GetPeer mocks base method.
func (m *MockService) GetPeer(arg0 context.Context, arg1 uint) (*models.Peer, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetPeer", arg0, arg1)
	ret0, _ := ret[0].(*models.Peer)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetPeer indicates an expected call of GetPeer.
func (mr *MockServiceMockRecorder) GetPeer(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetPeer", reflect.TypeOf((*MockService)(nil).GetPeer), arg0, arg1)
}

// GetPeers mocks base method.
func (m *MockService) GetPeers(arg0 context.Context, arg1 types.GetPeersQuery) ([]models.Peer, int64, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetPeers", arg0, arg1)
	ret0, _ := ret[0].([]models.Peer)
	ret1, _ := ret[1].(int64)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// GetPeers indicates an expected call of GetPeers.
func (mr *MockServiceMockRecorder) GetPeers(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetPeers", reflect.TypeOf((*MockService)(nil).GetPeers), arg0, arg1)
}

// GetPermissions mocks base method.
func (m *MockService) GetPermissions(arg0 context.Context, arg1 *gin.Engine) []rbac.Permission {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetPermissions", arg0, arg1)
	ret0, _ := ret[0].([]rbac.Permission)
	return ret0
}

// GetPermissions indicates an expected call of GetPermissions.
func (mr *MockServiceMockRecorder) GetPermissions(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetPermissions", reflect.TypeOf((*MockService)(nil).GetPermissions), arg0, arg1)
}

// GetPersonalAccessToken mocks base method.
func (m *MockService) GetPersonalAccessToken(arg0 context.Context, arg1 uint) (*models.PersonalAccessToken, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetPersonalAccessToken", arg0, arg1)
	ret0, _ := ret[0].(*models.PersonalAccessToken)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetPersonalAccessToken indicates an expected call of GetPersonalAccessToken.
func (mr *MockServiceMockRecorder) GetPersonalAccessToken(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetPersonalAccessToken", reflect.TypeOf((*MockService)(nil).GetPersonalAccessToken), arg0, arg1)
}

// GetPersonalAccessTokens mocks base method.
func (m *MockService) GetPersonalAccessTokens(arg0 context.Context, arg1 types.GetPersonalAccessTokensQuery) ([]models.PersonalAccessToken, int64, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetPersonalAccessTokens", arg0, arg1)
	ret0, _ := ret[0].([]models.PersonalAccessToken)
	ret1, _ := ret[1].(int64)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// GetPersonalAccessTokens indicates an expected call of GetPersonalAccessTokens.
func (mr *MockServiceMockRecorder) GetPersonalAccessTokens(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetPersonalAccessTokens", reflect.TypeOf((*MockService)(nil).GetPersonalAccessTokens), arg0, arg1)
}

// GetRole mocks base method.
func (m *MockService) GetRole(arg0 context.Context, arg1 string) [][]string {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetRole", arg0, arg1)
	ret0, _ := ret[0].([][]string)
	return ret0
}

// GetRole indicates an expected call of GetRole.
func (mr *MockServiceMockRecorder) GetRole(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetRole", reflect.TypeOf((*MockService)(nil).GetRole), arg0, arg1)
}

// GetRoles mocks base method.
func (m *MockService) GetRoles(arg0 context.Context) []string {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetRoles", arg0)
	ret0, _ := ret[0].([]string)
	return ret0
}

// GetRoles indicates an expected call of GetRoles.
func (mr *MockServiceMockRecorder) GetRoles(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetRoles", reflect.TypeOf((*MockService)(nil).GetRoles), arg0)
}

// GetRolesForUser mocks base method.
func (m *MockService) GetRolesForUser(arg0 context.Context, arg1 uint) ([]string, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetRolesForUser", arg0, arg1)
	ret0, _ := ret[0].([]string)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetRolesForUser indicates an expected call of GetRolesForUser.
func (mr *MockServiceMockRecorder) GetRolesForUser(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetRolesForUser", reflect.TypeOf((*MockService)(nil).GetRolesForUser), arg0, arg1)
}

// GetScheduler mocks base method.
func (m *MockService) GetScheduler(arg0 context.Context, arg1 uint) (*models.Scheduler, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetScheduler", arg0, arg1)
	ret0, _ := ret[0].(*models.Scheduler)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetScheduler indicates an expected call of GetScheduler.
func (mr *MockServiceMockRecorder) GetScheduler(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetScheduler", reflect.TypeOf((*MockService)(nil).GetScheduler), arg0, arg1)
}

// GetSchedulerCluster mocks base method.
func (m *MockService) GetSchedulerCluster(arg0 context.Context, arg1 uint) (*models.SchedulerCluster, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetSchedulerCluster", arg0, arg1)
	ret0, _ := ret[0].(*models.SchedulerCluster)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetSchedulerCluster indicates an expected call of GetSchedulerCluster.
func (mr *MockServiceMockRecorder) GetSchedulerCluster(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetSchedulerCluster", reflect.TypeOf((*MockService)(nil).GetSchedulerCluster), arg0, arg1)
}

// GetSchedulerClusters mocks base method.
func (m *MockService) GetSchedulerClusters(arg0 context.Context, arg1 types.GetSchedulerClustersQuery) ([]models.SchedulerCluster, int64, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetSchedulerClusters", arg0, arg1)
	ret0, _ := ret[0].([]models.SchedulerCluster)
	ret1, _ := ret[1].(int64)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// GetSchedulerClusters indicates an expected call of GetSchedulerClusters.
func (mr *MockServiceMockRecorder) GetSchedulerClusters(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetSchedulerClusters", reflect.TypeOf((*MockService)(nil).GetSchedulerClusters), arg0, arg1)
}

// GetSchedulers mocks base method.
func (m *MockService) GetSchedulers(arg0 context.Context, arg1 types.GetSchedulersQuery) ([]models.Scheduler, int64, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetSchedulers", arg0, arg1)
	ret0, _ := ret[0].([]models.Scheduler)
	ret1, _ := ret[1].(int64)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// GetSchedulers indicates an expected call of GetSchedulers.
func (mr *MockServiceMockRecorder) GetSchedulers(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetSchedulers", reflect.TypeOf((*MockService)(nil).GetSchedulers), arg0, arg1)
}

// GetSeedPeer mocks base method.
func (m *MockService) GetSeedPeer(arg0 context.Context, arg1 uint) (*models.SeedPeer, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetSeedPeer", arg0, arg1)
	ret0, _ := ret[0].(*models.SeedPeer)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetSeedPeer indicates an expected call of GetSeedPeer.
func (mr *MockServiceMockRecorder) GetSeedPeer(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetSeedPeer", reflect.TypeOf((*MockService)(nil).GetSeedPeer), arg0, arg1)
}

// GetSeedPeerCluster mocks base method.
func (m *MockService) GetSeedPeerCluster(arg0 context.Context, arg1 uint) (*models.SeedPeerCluster, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetSeedPeerCluster", arg0, arg1)
	ret0, _ := ret[0].(*models.SeedPeerCluster)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetSeedPeerCluster indicates an expected call of GetSeedPeerCluster.
func (mr *MockServiceMockRecorder) GetSeedPeerCluster(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetSeedPeerCluster", reflect.TypeOf((*MockService)(nil).GetSeedPeerCluster), arg0, arg1)
}

// GetSeedPeerClusters mocks base method.
func (m *MockService) GetSeedPeerClusters(arg0 context.Context, arg1 types.GetSeedPeerClustersQuery) ([]models.SeedPeerCluster, int64, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetSeedPeerClusters", arg0, arg1)
	ret0, _ := ret[0].([]models.SeedPeerCluster)
	ret1, _ := ret[1].(int64)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// GetSeedPeerClusters indicates an expected call of GetSeedPeerClusters.
func (mr *MockServiceMockRecorder) GetSeedPeerClusters(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetSeedPeerClusters", reflect.TypeOf((*MockService)(nil).GetSeedPeerClusters), arg0, arg1)
}

// GetSeedPeers mocks base method.
func (m *MockService) GetSeedPeers(arg0 context.Context, arg1 types.GetSeedPeersQuery) ([]models.SeedPeer, int64, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetSeedPeers", arg0, arg1)
	ret0, _ := ret[0].([]models.SeedPeer)
	ret1, _ := ret[1].(int64)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// GetSeedPeers indicates an expected call of GetSeedPeers.
func (mr *MockServiceMockRecorder) GetSeedPeers(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetSeedPeers", reflect.TypeOf((*MockService)(nil).GetSeedPeers), arg0, arg1)
}

// GetUser mocks base method.
func (m *MockService) GetUser(arg0 context.Context, arg1 uint) (*models.User, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetUser", arg0, arg1)
	ret0, _ := ret[0].(*models.User)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetUser indicates an expected call of GetUser.
func (mr *MockServiceMockRecorder) GetUser(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetUser", reflect.TypeOf((*MockService)(nil).GetUser), arg0, arg1)
}

// GetUsers mocks base method.
func (m *MockService) GetUsers(arg0 context.Context, arg1 types.GetUsersQuery) ([]models.User, int64, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetUsers", arg0, arg1)
	ret0, _ := ret[0].([]models.User)
	ret1, _ := ret[1].(int64)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// GetUsers indicates an expected call of GetUsers.
func (mr *MockServiceMockRecorder) GetUsers(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetUsers", reflect.TypeOf((*MockService)(nil).GetUsers), arg0, arg1)
}

// GetV1Preheat mocks base method.
func (m *MockService) GetV1Preheat(arg0 context.Context, arg1 string) (*types.GetV1PreheatResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetV1Preheat", arg0, arg1)
	ret0, _ := ret[0].(*types.GetV1PreheatResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetV1Preheat indicates an expected call of GetV1Preheat.
func (mr *MockServiceMockRecorder) GetV1Preheat(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetV1Preheat", reflect.TypeOf((*MockService)(nil).GetV1Preheat), arg0, arg1)
}

// OauthSignin mocks base method.
func (m *MockService) OauthSignin(arg0 context.Context, arg1 string) (string, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "OauthSignin", arg0, arg1)
	ret0, _ := ret[0].(string)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// OauthSignin indicates an expected call of OauthSignin.
func (mr *MockServiceMockRecorder) OauthSignin(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "OauthSignin", reflect.TypeOf((*MockService)(nil).OauthSignin), arg0, arg1)
}

// OauthSigninCallback mocks base method.
func (m *MockService) OauthSigninCallback(arg0 context.Context, arg1, arg2 string) (*models.User, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "OauthSigninCallback", arg0, arg1, arg2)
	ret0, _ := ret[0].(*models.User)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// OauthSigninCallback indicates an expected call of OauthSigninCallback.
func (mr *MockServiceMockRecorder) OauthSigninCallback(arg0, arg1, arg2 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "OauthSigninCallback", reflect.TypeOf((*MockService)(nil).OauthSigninCallback), arg0, arg1, arg2)
}

// ResetPassword mocks base method.
func (m *MockService) ResetPassword(arg0 context.Context, arg1 uint, arg2 types.ResetPasswordRequest) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ResetPassword", arg0, arg1, arg2)
	ret0, _ := ret[0].(error)
	return ret0
}

// ResetPassword indicates an expected call of ResetPassword.
func (mr *MockServiceMockRecorder) ResetPassword(arg0, arg1, arg2 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ResetPassword", reflect.TypeOf((*MockService)(nil).ResetPassword), arg0, arg1, arg2)
}

// SignIn mocks base method.
func (m *MockService) SignIn(arg0 context.Context, arg1 types.SignInRequest) (*models.User, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SignIn", arg0, arg1)
	ret0, _ := ret[0].(*models.User)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// SignIn indicates an expected call of SignIn.
func (mr *MockServiceMockRecorder) SignIn(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SignIn", reflect.TypeOf((*MockService)(nil).SignIn), arg0, arg1)
}

// SignUp mocks base method.
func (m *MockService) SignUp(arg0 context.Context, arg1 types.SignUpRequest) (*models.User, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SignUp", arg0, arg1)
	ret0, _ := ret[0].(*models.User)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// SignUp indicates an expected call of SignUp.
func (mr *MockServiceMockRecorder) SignUp(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SignUp", reflect.TypeOf((*MockService)(nil).SignUp), arg0, arg1)
}

// UpdateApplication mocks base method.
func (m *MockService) UpdateApplication(arg0 context.Context, arg1 uint, arg2 types.UpdateApplicationRequest) (*models.Application, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateApplication", arg0, arg1, arg2)
	ret0, _ := ret[0].(*models.Application)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UpdateApplication indicates an expected call of UpdateApplication.
func (mr *MockServiceMockRecorder) UpdateApplication(arg0, arg1, arg2 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateApplication", reflect.TypeOf((*MockService)(nil).UpdateApplication), arg0, arg1, arg2)
}

// UpdateCluster mocks base method.
func (m *MockService) UpdateCluster(arg0 context.Context, arg1 uint, arg2 types.UpdateClusterRequest) (*types.UpdateClusterResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateCluster", arg0, arg1, arg2)
	ret0, _ := ret[0].(*types.UpdateClusterResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UpdateCluster indicates an expected call of UpdateCluster.
func (mr *MockServiceMockRecorder) UpdateCluster(arg0, arg1, arg2 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateCluster", reflect.TypeOf((*MockService)(nil).UpdateCluster), arg0, arg1, arg2)
}

// UpdateConfig mocks base method.
func (m *MockService) UpdateConfig(arg0 context.Context, arg1 uint, arg2 types.UpdateConfigRequest) (*models.Config, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateConfig", arg0, arg1, arg2)
	ret0, _ := ret[0].(*models.Config)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UpdateConfig indicates an expected call of UpdateConfig.
func (mr *MockServiceMockRecorder) UpdateConfig(arg0, arg1, arg2 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateConfig", reflect.TypeOf((*MockService)(nil).UpdateConfig), arg0, arg1, arg2)
}

// UpdateJob mocks base method.
func (m *MockService) UpdateJob(arg0 context.Context, arg1 uint, arg2 types.UpdateJobRequest) (*models.Job, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateJob", arg0, arg1, arg2)
	ret0, _ := ret[0].(*models.Job)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UpdateJob indicates an expected call of UpdateJob.
func (mr *MockServiceMockRecorder) UpdateJob(arg0, arg1, arg2 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateJob", reflect.TypeOf((*MockService)(nil).UpdateJob), arg0, arg1, arg2)
}

// UpdateModel mocks base method.
func (m *MockService) UpdateModel(arg0 context.Context, arg1 uint, arg2 types.UpdateModelRequest) (*models.Model, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateModel", arg0, arg1, arg2)
	ret0, _ := ret[0].(*models.Model)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UpdateModel indicates an expected call of UpdateModel.
func (mr *MockServiceMockRecorder) UpdateModel(arg0, arg1, arg2 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateModel", reflect.TypeOf((*MockService)(nil).UpdateModel), arg0, arg1, arg2)
}

// UpdateOauth mocks base method.
func (m *MockService) UpdateOauth(arg0 context.Context, arg1 uint, arg2 types.UpdateOauthRequest) (*models.Oauth, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateOauth", arg0, arg1, arg2)
	ret0, _ := ret[0].(*models.Oauth)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UpdateOauth indicates an expected call of UpdateOauth.
func (mr *MockServiceMockRecorder) UpdateOauth(arg0, arg1, arg2 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateOauth", reflect.TypeOf((*MockService)(nil).UpdateOauth), arg0, arg1, arg2)
}

// UpdatePersonalAccessToken mocks base method.
func (m *MockService) UpdatePersonalAccessToken(arg0 context.Context, arg1 uint, arg2 types.UpdatePersonalAccessTokenRequest) (*models.PersonalAccessToken, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdatePersonalAccessToken", arg0, arg1, arg2)
	ret0, _ := ret[0].(*models.PersonalAccessToken)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UpdatePersonalAccessToken indicates an expected call of UpdatePersonalAccessToken.
func (mr *MockServiceMockRecorder) UpdatePersonalAccessToken(arg0, arg1, arg2 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdatePersonalAccessToken", reflect.TypeOf((*MockService)(nil).UpdatePersonalAccessToken), arg0, arg1, arg2)
}

// UpdateScheduler mocks base method.
func (m *MockService) UpdateScheduler(arg0 context.Context, arg1 uint, arg2 types.UpdateSchedulerRequest) (*models.Scheduler, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateScheduler", arg0, arg1, arg2)
	ret0, _ := ret[0].(*models.Scheduler)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UpdateScheduler indicates an expected call of UpdateScheduler.
func (mr *MockServiceMockRecorder) UpdateScheduler(arg0, arg1, arg2 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateScheduler", reflect.TypeOf((*MockService)(nil).UpdateScheduler), arg0, arg1, arg2)
}

// UpdateSchedulerCluster mocks base method.
func (m *MockService) UpdateSchedulerCluster(arg0 context.Context, arg1 uint, arg2 types.UpdateSchedulerClusterRequest) (*models.SchedulerCluster, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateSchedulerCluster", arg0, arg1, arg2)
	ret0, _ := ret[0].(*models.SchedulerCluster)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UpdateSchedulerCluster indicates an expected call of UpdateSchedulerCluster.
func (mr *MockServiceMockRecorder) UpdateSchedulerCluster(arg0, arg1, arg2 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateSchedulerCluster", reflect.TypeOf((*MockService)(nil).UpdateSchedulerCluster), arg0, arg1, arg2)
}

// UpdateSeedPeer mocks base method.
func (m *MockService) UpdateSeedPeer(arg0 context.Context, arg1 uint, arg2 types.UpdateSeedPeerRequest) (*models.SeedPeer, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateSeedPeer", arg0, arg1, arg2)
	ret0, _ := ret[0].(*models.SeedPeer)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UpdateSeedPeer indicates an expected call of UpdateSeedPeer.
func (mr *MockServiceMockRecorder) UpdateSeedPeer(arg0, arg1, arg2 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateSeedPeer", reflect.TypeOf((*MockService)(nil).UpdateSeedPeer), arg0, arg1, arg2)
}

// UpdateSeedPeerCluster mocks base method.
func (m *MockService) UpdateSeedPeerCluster(arg0 context.Context, arg1 uint, arg2 types.UpdateSeedPeerClusterRequest) (*models.SeedPeerCluster, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateSeedPeerCluster", arg0, arg1, arg2)
	ret0, _ := ret[0].(*models.SeedPeerCluster)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UpdateSeedPeerCluster indicates an expected call of UpdateSeedPeerCluster.
func (mr *MockServiceMockRecorder) UpdateSeedPeerCluster(arg0, arg1, arg2 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateSeedPeerCluster", reflect.TypeOf((*MockService)(nil).UpdateSeedPeerCluster), arg0, arg1, arg2)
}

// UpdateUser mocks base method.
func (m *MockService) UpdateUser(arg0 context.Context, arg1 uint, arg2 types.UpdateUserRequest) (*models.User, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateUser", arg0, arg1, arg2)
	ret0, _ := ret[0].(*models.User)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UpdateUser indicates an expected call of UpdateUser.
func (mr *MockServiceMockRecorder) UpdateUser(arg0, arg1, arg2 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateUser", reflect.TypeOf((*MockService)(nil).UpdateUser), arg0, arg1, arg2)
}