// Code generated by mockery; DO NOT EDIT.
// github.com/vektra/mockery
// template: testify

package actions

import (
	"context"

	"github.com/google/uuid"
	mock "github.com/stretchr/testify/mock"
)

// NewMockActionsService creates a new instance of MockActionsService. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
// The first argument is typically a *testing.T value.
func NewMockActionsService(t interface {
	mock.TestingT
	Cleanup(func())
}) *MockActionsService {
	mock := &MockActionsService{}
	mock.Mock.Test(t)

	t.Cleanup(func() { mock.AssertExpectations(t) })

	return mock
}

// MockActionsService is an autogenerated mock type for the ActionsService type
type MockActionsService struct {
	mock.Mock
}

type MockActionsService_Expecter struct {
	mock *mock.Mock
}

func (_m *MockActionsService) EXPECT() *MockActionsService_Expecter {
	return &MockActionsService_Expecter{mock: &_m.Mock}
}

// AcquireJobs provides a mock function for the type MockActionsService
func (_mock *MockActionsService) AcquireJobs(ctx context.Context, runnerScaleSetId int, messageQueueAccessToken string, requestIds []int64) ([]int64, error) {
	ret := _mock.Called(ctx, runnerScaleSetId, messageQueueAccessToken, requestIds)

	if len(ret) == 0 {
		panic("no return value specified for AcquireJobs")
	}

	var r0 []int64
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, int, string, []int64) ([]int64, error)); ok {
		return returnFunc(ctx, runnerScaleSetId, messageQueueAccessToken, requestIds)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, int, string, []int64) []int64); ok {
		r0 = returnFunc(ctx, runnerScaleSetId, messageQueueAccessToken, requestIds)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]int64)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, int, string, []int64) error); ok {
		r1 = returnFunc(ctx, runnerScaleSetId, messageQueueAccessToken, requestIds)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// MockActionsService_AcquireJobs_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AcquireJobs'
type MockActionsService_AcquireJobs_Call struct {
	*mock.Call
}

// AcquireJobs is a helper method to define mock.On call
//   - ctx context.Context
//   - runnerScaleSetId int
//   - messageQueueAccessToken string
//   - requestIds []int64
func (_e *MockActionsService_Expecter) AcquireJobs(ctx interface{}, runnerScaleSetId interface{}, messageQueueAccessToken interface{}, requestIds interface{}) *MockActionsService_AcquireJobs_Call {
	return &MockActionsService_AcquireJobs_Call{Call: _e.mock.On("AcquireJobs", ctx, runnerScaleSetId, messageQueueAccessToken, requestIds)}
}

func (_c *MockActionsService_AcquireJobs_Call) Run(run func(ctx context.Context, runnerScaleSetId int, messageQueueAccessToken string, requestIds []int64)) *MockActionsService_AcquireJobs_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 int
		if args[1] != nil {
			arg1 = args[1].(int)
		}
		var arg2 string
		if args[2] != nil {
			arg2 = args[2].(string)
		}
		var arg3 []int64
		if args[3] != nil {
			arg3 = args[3].([]int64)
		}
		run(
			arg0,
			arg1,
			arg2,
			arg3,
		)
	})
	return _c
}

func (_c *MockActionsService_AcquireJobs_Call) Return(int64s []int64, err error) *MockActionsService_AcquireJobs_Call {
	_c.Call.Return(int64s, err)
	return _c
}

func (_c *MockActionsService_AcquireJobs_Call) RunAndReturn(run func(ctx context.Context, runnerScaleSetId int, messageQueueAccessToken string, requestIds []int64) ([]int64, error)) *MockActionsService_AcquireJobs_Call {
	_c.Call.Return(run)
	return _c
}

// CreateMessageSession provides a mock function for the type MockActionsService
func (_mock *MockActionsService) CreateMessageSession(ctx context.Context, runnerScaleSetId int, owner string) (*RunnerScaleSetSession, error) {
	ret := _mock.Called(ctx, runnerScaleSetId, owner)

	if len(ret) == 0 {
		panic("no return value specified for CreateMessageSession")
	}

	var r0 *RunnerScaleSetSession
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, int, string) (*RunnerScaleSetSession, error)); ok {
		return returnFunc(ctx, runnerScaleSetId, owner)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, int, string) *RunnerScaleSetSession); ok {
		r0 = returnFunc(ctx, runnerScaleSetId, owner)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*RunnerScaleSetSession)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, int, string) error); ok {
		r1 = returnFunc(ctx, runnerScaleSetId, owner)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// MockActionsService_CreateMessageSession_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateMessageSession'
type MockActionsService_CreateMessageSession_Call struct {
	*mock.Call
}

// CreateMessageSession is a helper method to define mock.On call
//   - ctx context.Context
//   - runnerScaleSetId int
//   - owner string
func (_e *MockActionsService_Expecter) CreateMessageSession(ctx interface{}, runnerScaleSetId interface{}, owner interface{}) *MockActionsService_CreateMessageSession_Call {
	return &MockActionsService_CreateMessageSession_Call{Call: _e.mock.On("CreateMessageSession", ctx, runnerScaleSetId, owner)}
}

func (_c *MockActionsService_CreateMessageSession_Call) Run(run func(ctx context.Context, runnerScaleSetId int, owner string)) *MockActionsService_CreateMessageSession_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 int
		if args[1] != nil {
			arg1 = args[1].(int)
		}
		var arg2 string
		if args[2] != nil {
			arg2 = args[2].(string)
		}
		run(
			arg0,
			arg1,
			arg2,
		)
	})
	return _c
}

func (_c *MockActionsService_CreateMessageSession_Call) Return(runnerScaleSetSession *RunnerScaleSetSession, err error) *MockActionsService_CreateMessageSession_Call {
	_c.Call.Return(runnerScaleSetSession, err)
	return _c
}

func (_c *MockActionsService_CreateMessageSession_Call) RunAndReturn(run func(ctx context.Context, runnerScaleSetId int, owner string) (*RunnerScaleSetSession, error)) *MockActionsService_CreateMessageSession_Call {
	_c.Call.Return(run)
	return _c
}

// CreateRunnerScaleSet provides a mock function for the type MockActionsService
func (_mock *MockActionsService) CreateRunnerScaleSet(ctx context.Context, runnerScaleSet *RunnerScaleSet) (*RunnerScaleSet, error) {
	ret := _mock.Called(ctx, runnerScaleSet)

	if len(ret) == 0 {
		panic("no return value specified for CreateRunnerScaleSet")
	}

	var r0 *RunnerScaleSet
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, *RunnerScaleSet) (*RunnerScaleSet, error)); ok {
		return returnFunc(ctx, runnerScaleSet)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, *RunnerScaleSet) *RunnerScaleSet); ok {
		r0 = returnFunc(ctx, runnerScaleSet)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*RunnerScaleSet)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, *RunnerScaleSet) error); ok {
		r1 = returnFunc(ctx, runnerScaleSet)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// MockActionsService_CreateRunnerScaleSet_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateRunnerScaleSet'
type MockActionsService_CreateRunnerScaleSet_Call struct {
	*mock.Call
}

// CreateRunnerScaleSet is a helper method to define mock.On call
//   - ctx context.Context
//   - runnerScaleSet *RunnerScaleSet
func (_e *MockActionsService_Expecter) CreateRunnerScaleSet(ctx interface{}, runnerScaleSet interface{}) *MockActionsService_CreateRunnerScaleSet_Call {
	return &MockActionsService_CreateRunnerScaleSet_Call{Call: _e.mock.On("CreateRunnerScaleSet", ctx, runnerScaleSet)}
}

func (_c *MockActionsService_CreateRunnerScaleSet_Call) Run(run func(ctx context.Context, runnerScaleSet *RunnerScaleSet)) *MockActionsService_CreateRunnerScaleSet_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 *RunnerScaleSet
		if args[1] != nil {
			arg1 = args[1].(*RunnerScaleSet)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *MockActionsService_CreateRunnerScaleSet_Call) Return(runnerScaleSet1 *RunnerScaleSet, err error) *MockActionsService_CreateRunnerScaleSet_Call {
	_c.Call.Return(runnerScaleSet1, err)
	return _c
}

func (_c *MockActionsService_CreateRunnerScaleSet_Call) RunAndReturn(run func(ctx context.Context, runnerScaleSet *RunnerScaleSet) (*RunnerScaleSet, error)) *MockActionsService_CreateRunnerScaleSet_Call {
	_c.Call.Return(run)
	return _c
}

// DeleteMessage provides a mock function for the type MockActionsService
func (_mock *MockActionsService) DeleteMessage(ctx context.Context, messageQueueUrl string, messageQueueAccessToken string, messageId int64) error {
	ret := _mock.Called(ctx, messageQueueUrl, messageQueueAccessToken, messageId)

	if len(ret) == 0 {
		panic("no return value specified for DeleteMessage")
	}

	var r0 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, int64) error); ok {
		r0 = returnFunc(ctx, messageQueueUrl, messageQueueAccessToken, messageId)
	} else {
		r0 = ret.Error(0)
	}
	return r0
}

// MockActionsService_DeleteMessage_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteMessage'
type MockActionsService_DeleteMessage_Call struct {
	*mock.Call
}

// DeleteMessage is a helper method to define mock.On call
//   - ctx context.Context
//   - messageQueueUrl string
//   - messageQueueAccessToken string
//   - messageId int64
func (_e *MockActionsService_Expecter) DeleteMessage(ctx interface{}, messageQueueUrl interface{}, messageQueueAccessToken interface{}, messageId interface{}) *MockActionsService_DeleteMessage_Call {
	return &MockActionsService_DeleteMessage_Call{Call: _e.mock.On("DeleteMessage", ctx, messageQueueUrl, messageQueueAccessToken, messageId)}
}

func (_c *MockActionsService_DeleteMessage_Call) Run(run func(ctx context.Context, messageQueueUrl string, messageQueueAccessToken string, messageId int64)) *MockActionsService_DeleteMessage_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 string
		if args[1] != nil {
			arg1 = args[1].(string)
		}
		var arg2 string
		if args[2] != nil {
			arg2 = args[2].(string)
		}
		var arg3 int64
		if args[3] != nil {
			arg3 = args[3].(int64)
		}
		run(
			arg0,
			arg1,
			arg2,
			arg3,
		)
	})
	return _c
}

func (_c *MockActionsService_DeleteMessage_Call) Return(err error) *MockActionsService_DeleteMessage_Call {
	_c.Call.Return(err)
	return _c
}

func (_c *MockActionsService_DeleteMessage_Call) RunAndReturn(run func(ctx context.Context, messageQueueUrl string, messageQueueAccessToken string, messageId int64) error) *MockActionsService_DeleteMessage_Call {
	_c.Call.Return(run)
	return _c
}

// DeleteMessageSession provides a mock function for the type MockActionsService
func (_mock *MockActionsService) DeleteMessageSession(ctx context.Context, runnerScaleSetId int, sessionId *uuid.UUID) error {
	ret := _mock.Called(ctx, runnerScaleSetId, sessionId)

	if len(ret) == 0 {
		panic("no return value specified for DeleteMessageSession")
	}

	var r0 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, int, *uuid.UUID) error); ok {
		r0 = returnFunc(ctx, runnerScaleSetId, sessionId)
	} else {
		r0 = ret.Error(0)
	}
	return r0
}

// MockActionsService_DeleteMessageSession_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteMessageSession'
type MockActionsService_DeleteMessageSession_Call struct {
	*mock.Call
}

// DeleteMessageSession is a helper method to define mock.On call
//   - ctx context.Context
//   - runnerScaleSetId int
//   - sessionId *uuid.UUID
func (_e *MockActionsService_Expecter) DeleteMessageSession(ctx interface{}, runnerScaleSetId interface{}, sessionId interface{}) *MockActionsService_DeleteMessageSession_Call {
	return &MockActionsService_DeleteMessageSession_Call{Call: _e.mock.On("DeleteMessageSession", ctx, runnerScaleSetId, sessionId)}
}

func (_c *MockActionsService_DeleteMessageSession_Call) Run(run func(ctx context.Context, runnerScaleSetId int, sessionId *uuid.UUID)) *MockActionsService_DeleteMessageSession_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 int
		if args[1] != nil {
			arg1 = args[1].(int)
		}
		var arg2 *uuid.UUID
		if args[2] != nil {
			arg2 = args[2].(*uuid.UUID)
		}
		run(
			arg0,
			arg1,
			arg2,
		)
	})
	return _c
}

func (_c *MockActionsService_DeleteMessageSession_Call) Return(err error) *MockActionsService_DeleteMessageSession_Call {
	_c.Call.Return(err)
	return _c
}

func (_c *MockActionsService_DeleteMessageSession_Call) RunAndReturn(run func(ctx context.Context, runnerScaleSetId int, sessionId *uuid.UUID) error) *MockActionsService_DeleteMessageSession_Call {
	_c.Call.Return(run)
	return _c
}

// DeleteRunnerScaleSet provides a mock function for the type MockActionsService
func (_mock *MockActionsService) DeleteRunnerScaleSet(ctx context.Context, runnerScaleSetId int) error {
	ret := _mock.Called(ctx, runnerScaleSetId)

	if len(ret) == 0 {
		panic("no return value specified for DeleteRunnerScaleSet")
	}

	var r0 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, int) error); ok {
		r0 = returnFunc(ctx, runnerScaleSetId)
	} else {
		r0 = ret.Error(0)
	}
	return r0
}

// MockActionsService_DeleteRunnerScaleSet_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteRunnerScaleSet'
type MockActionsService_DeleteRunnerScaleSet_Call struct {
	*mock.Call
}

// DeleteRunnerScaleSet is a helper method to define mock.On call
//   - ctx context.Context
//   - runnerScaleSetId int
func (_e *MockActionsService_Expecter) DeleteRunnerScaleSet(ctx interface{}, runnerScaleSetId interface{}) *MockActionsService_DeleteRunnerScaleSet_Call {
	return &MockActionsService_DeleteRunnerScaleSet_Call{Call: _e.mock.On("DeleteRunnerScaleSet", ctx, runnerScaleSetId)}
}

func (_c *MockActionsService_DeleteRunnerScaleSet_Call) Run(run func(ctx context.Context, runnerScaleSetId int)) *MockActionsService_DeleteRunnerScaleSet_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 int
		if args[1] != nil {
			arg1 = args[1].(int)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *MockActionsService_DeleteRunnerScaleSet_Call) Return(err error) *MockActionsService_DeleteRunnerScaleSet_Call {
	_c.Call.Return(err)
	return _c
}

func (_c *MockActionsService_DeleteRunnerScaleSet_Call) RunAndReturn(run func(ctx context.Context, runnerScaleSetId int) error) *MockActionsService_DeleteRunnerScaleSet_Call {
	_c.Call.Return(run)
	return _c
}

// GenerateJitRunnerConfig provides a mock function for the type MockActionsService
func (_mock *MockActionsService) GenerateJitRunnerConfig(ctx context.Context, jitRunnerSetting *RunnerScaleSetJitRunnerSetting, scaleSetId int) (*RunnerScaleSetJitRunnerConfig, error) {
	ret := _mock.Called(ctx, jitRunnerSetting, scaleSetId)

	if len(ret) == 0 {
		panic("no return value specified for GenerateJitRunnerConfig")
	}

	var r0 *RunnerScaleSetJitRunnerConfig
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, *RunnerScaleSetJitRunnerSetting, int) (*RunnerScaleSetJitRunnerConfig, error)); ok {
		return returnFunc(ctx, jitRunnerSetting, scaleSetId)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, *RunnerScaleSetJitRunnerSetting, int) *RunnerScaleSetJitRunnerConfig); ok {
		r0 = returnFunc(ctx, jitRunnerSetting, scaleSetId)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*RunnerScaleSetJitRunnerConfig)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, *RunnerScaleSetJitRunnerSetting, int) error); ok {
		r1 = returnFunc(ctx, jitRunnerSetting, scaleSetId)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// MockActionsService_GenerateJitRunnerConfig_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GenerateJitRunnerConfig'
type MockActionsService_GenerateJitRunnerConfig_Call struct {
	*mock.Call
}

// GenerateJitRunnerConfig is a helper method to define mock.On call
//   - ctx context.Context
//   - jitRunnerSetting *RunnerScaleSetJitRunnerSetting
//   - scaleSetId int
func (_e *MockActionsService_Expecter) GenerateJitRunnerConfig(ctx interface{}, jitRunnerSetting interface{}, scaleSetId interface{}) *MockActionsService_GenerateJitRunnerConfig_Call {
	return &MockActionsService_GenerateJitRunnerConfig_Call{Call: _e.mock.On("GenerateJitRunnerConfig", ctx, jitRunnerSetting, scaleSetId)}
}

func (_c *MockActionsService_GenerateJitRunnerConfig_Call) Run(run func(ctx context.Context, jitRunnerSetting *RunnerScaleSetJitRunnerSetting, scaleSetId int)) *MockActionsService_GenerateJitRunnerConfig_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 *RunnerScaleSetJitRunnerSetting
		if args[1] != nil {
			arg1 = args[1].(*RunnerScaleSetJitRunnerSetting)
		}
		var arg2 int
		if args[2] != nil {
			arg2 = args[2].(int)
		}
		run(
			arg0,
			arg1,
			arg2,
		)
	})
	return _c
}

func (_c *MockActionsService_GenerateJitRunnerConfig_Call) Return(runnerScaleSetJitRunnerConfig *RunnerScaleSetJitRunnerConfig, err error) *MockActionsService_GenerateJitRunnerConfig_Call {
	_c.Call.Return(runnerScaleSetJitRunnerConfig, err)
	return _c
}

func (_c *MockActionsService_GenerateJitRunnerConfig_Call) RunAndReturn(run func(ctx context.Context, jitRunnerSetting *RunnerScaleSetJitRunnerSetting, scaleSetId int) (*RunnerScaleSetJitRunnerConfig, error)) *MockActionsService_GenerateJitRunnerConfig_Call {
	_c.Call.Return(run)
	return _c
}

// GetAcquirableJobs provides a mock function for the type MockActionsService
func (_mock *MockActionsService) GetAcquirableJobs(ctx context.Context, runnerScaleSetId int) (*AcquirableJobList, error) {
	ret := _mock.Called(ctx, runnerScaleSetId)

	if len(ret) == 0 {
		panic("no return value specified for GetAcquirableJobs")
	}

	var r0 *AcquirableJobList
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, int) (*AcquirableJobList, error)); ok {
		return returnFunc(ctx, runnerScaleSetId)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, int) *AcquirableJobList); ok {
		r0 = returnFunc(ctx, runnerScaleSetId)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*AcquirableJobList)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, int) error); ok {
		r1 = returnFunc(ctx, runnerScaleSetId)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// MockActionsService_GetAcquirableJobs_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetAcquirableJobs'
type MockActionsService_GetAcquirableJobs_Call struct {
	*mock.Call
}

// GetAcquirableJobs is a helper method to define mock.On call
//   - ctx context.Context
//   - runnerScaleSetId int
func (_e *MockActionsService_Expecter) GetAcquirableJobs(ctx interface{}, runnerScaleSetId interface{}) *MockActionsService_GetAcquirableJobs_Call {
	return &MockActionsService_GetAcquirableJobs_Call{Call: _e.mock.On("GetAcquirableJobs", ctx, runnerScaleSetId)}
}

func (_c *MockActionsService_GetAcquirableJobs_Call) Run(run func(ctx context.Context, runnerScaleSetId int)) *MockActionsService_GetAcquirableJobs_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 int
		if args[1] != nil {
			arg1 = args[1].(int)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *MockActionsService_GetAcquirableJobs_Call) Return(acquirableJobList *AcquirableJobList, err error) *MockActionsService_GetAcquirableJobs_Call {
	_c.Call.Return(acquirableJobList, err)
	return _c
}

func (_c *MockActionsService_GetAcquirableJobs_Call) RunAndReturn(run func(ctx context.Context, runnerScaleSetId int) (*AcquirableJobList, error)) *MockActionsService_GetAcquirableJobs_Call {
	_c.Call.Return(run)
	return _c
}

// GetMessage provides a mock function for the type MockActionsService
func (_mock *MockActionsService) GetMessage(ctx context.Context, messageQueueUrl string, messageQueueAccessToken string, lastMessageId int64, maxCapacity int) (*RunnerScaleSetMessage, error) {
	ret := _mock.Called(ctx, messageQueueUrl, messageQueueAccessToken, lastMessageId, maxCapacity)

	if len(ret) == 0 {
		panic("no return value specified for GetMessage")
	}

	var r0 *RunnerScaleSetMessage
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, int64, int) (*RunnerScaleSetMessage, error)); ok {
		return returnFunc(ctx, messageQueueUrl, messageQueueAccessToken, lastMessageId, maxCapacity)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, int64, int) *RunnerScaleSetMessage); ok {
		r0 = returnFunc(ctx, messageQueueUrl, messageQueueAccessToken, lastMessageId, maxCapacity)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*RunnerScaleSetMessage)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string, string, int64, int) error); ok {
		r1 = returnFunc(ctx, messageQueueUrl, messageQueueAccessToken, lastMessageId, maxCapacity)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// MockActionsService_GetMessage_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetMessage'
type MockActionsService_GetMessage_Call struct {
	*mock.Call
}

// GetMessage is a helper method to define mock.On call
//   - ctx context.Context
//   - messageQueueUrl string
//   - messageQueueAccessToken string
//   - lastMessageId int64
//   - maxCapacity int
func (_e *MockActionsService_Expecter) GetMessage(ctx interface{}, messageQueueUrl interface{}, messageQueueAccessToken interface{}, lastMessageId interface{}, maxCapacity interface{}) *MockActionsService_GetMessage_Call {
	return &MockActionsService_GetMessage_Call{Call: _e.mock.On("GetMessage", ctx, messageQueueUrl, messageQueueAccessToken, lastMessageId, maxCapacity)}
}

func (_c *MockActionsService_GetMessage_Call) Run(run func(ctx context.Context, messageQueueUrl string, messageQueueAccessToken string, lastMessageId int64, maxCapacity int)) *MockActionsService_GetMessage_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 string
		if args[1] != nil {
			arg1 = args[1].(string)
		}
		var arg2 string
		if args[2] != nil {
			arg2 = args[2].(string)
		}
		var arg3 int64
		if args[3] != nil {
			arg3 = args[3].(int64)
		}
		var arg4 int
		if args[4] != nil {
			arg4 = args[4].(int)
		}
		run(
			arg0,
			arg1,
			arg2,
			arg3,
			arg4,
		)
	})
	return _c
}

func (_c *MockActionsService_GetMessage_Call) Return(runnerScaleSetMessage *RunnerScaleSetMessage, err error) *MockActionsService_GetMessage_Call {
	_c.Call.Return(runnerScaleSetMessage, err)
	return _c
}

func (_c *MockActionsService_GetMessage_Call) RunAndReturn(run func(ctx context.Context, messageQueueUrl string, messageQueueAccessToken string, lastMessageId int64, maxCapacity int) (*RunnerScaleSetMessage, error)) *MockActionsService_GetMessage_Call {
	_c.Call.Return(run)
	return _c
}

// GetRunner provides a mock function for the type MockActionsService
func (_mock *MockActionsService) GetRunner(ctx context.Context, runnerId int64) (*RunnerReference, error) {
	ret := _mock.Called(ctx, runnerId)

	if len(ret) == 0 {
		panic("no return value specified for GetRunner")
	}

	var r0 *RunnerReference
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, int64) (*RunnerReference, error)); ok {
		return returnFunc(ctx, runnerId)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, int64) *RunnerReference); ok {
		r0 = returnFunc(ctx, runnerId)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*RunnerReference)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, int64) error); ok {
		r1 = returnFunc(ctx, runnerId)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// MockActionsService_GetRunner_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetRunner'
type MockActionsService_GetRunner_Call struct {
	*mock.Call
}

// GetRunner is a helper method to define mock.On call
//   - ctx context.Context
//   - runnerId int64
func (_e *MockActionsService_Expecter) GetRunner(ctx interface{}, runnerId interface{}) *MockActionsService_GetRunner_Call {
	return &MockActionsService_GetRunner_Call{Call: _e.mock.On("GetRunner", ctx, runnerId)}
}

func (_c *MockActionsService_GetRunner_Call) Run(run func(ctx context.Context, runnerId int64)) *MockActionsService_GetRunner_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 int64
		if args[1] != nil {
			arg1 = args[1].(int64)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *MockActionsService_GetRunner_Call) Return(runnerReference *RunnerReference, err error) *MockActionsService_GetRunner_Call {
	_c.Call.Return(runnerReference, err)
	return _c
}

func (_c *MockActionsService_GetRunner_Call) RunAndReturn(run func(ctx context.Context, runnerId int64) (*RunnerReference, error)) *MockActionsService_GetRunner_Call {
	_c.Call.Return(run)
	return _c
}

// GetRunnerByName provides a mock function for the type MockActionsService
func (_mock *MockActionsService) GetRunnerByName(ctx context.Context, runnerName string) (*RunnerReference, error) {
	ret := _mock.Called(ctx, runnerName)

	if len(ret) == 0 {
		panic("no return value specified for GetRunnerByName")
	}

	var r0 *RunnerReference
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string) (*RunnerReference, error)); ok {
		return returnFunc(ctx, runnerName)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string) *RunnerReference); ok {
		r0 = returnFunc(ctx, runnerName)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*RunnerReference)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string) error); ok {
		r1 = returnFunc(ctx, runnerName)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// MockActionsService_GetRunnerByName_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetRunnerByName'
type MockActionsService_GetRunnerByName_Call struct {
	*mock.Call
}

// GetRunnerByName is a helper method to define mock.On call
//   - ctx context.Context
//   - runnerName string
func (_e *MockActionsService_Expecter) GetRunnerByName(ctx interface{}, runnerName interface{}) *MockActionsService_GetRunnerByName_Call {
	return &MockActionsService_GetRunnerByName_Call{Call: _e.mock.On("GetRunnerByName", ctx, runnerName)}
}

func (_c *MockActionsService_GetRunnerByName_Call) Run(run func(ctx context.Context, runnerName string)) *MockActionsService_GetRunnerByName_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 string
		if args[1] != nil {
			arg1 = args[1].(string)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *MockActionsService_GetRunnerByName_Call) Return(runnerReference *RunnerReference, err error) *MockActionsService_GetRunnerByName_Call {
	_c.Call.Return(runnerReference, err)
	return _c
}

func (_c *MockActionsService_GetRunnerByName_Call) RunAndReturn(run func(ctx context.Context, runnerName string) (*RunnerReference, error)) *MockActionsService_GetRunnerByName_Call {
	_c.Call.Return(run)
	return _c
}

// GetRunnerGroupByName provides a mock function for the type MockActionsService
func (_mock *MockActionsService) GetRunnerGroupByName(ctx context.Context, runnerGroup string) (*RunnerGroup, error) {
	ret := _mock.Called(ctx, runnerGroup)

	if len(ret) == 0 {
		panic("no return value specified for GetRunnerGroupByName")
	}

	var r0 *RunnerGroup
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string) (*RunnerGroup, error)); ok {
		return returnFunc(ctx, runnerGroup)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string) *RunnerGroup); ok {
		r0 = returnFunc(ctx, runnerGroup)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*RunnerGroup)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string) error); ok {
		r1 = returnFunc(ctx, runnerGroup)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// MockActionsService_GetRunnerGroupByName_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetRunnerGroupByName'
type MockActionsService_GetRunnerGroupByName_Call struct {
	*mock.Call
}

// GetRunnerGroupByName is a helper method to define mock.On call
//   - ctx context.Context
//   - runnerGroup string
func (_e *MockActionsService_Expecter) GetRunnerGroupByName(ctx interface{}, runnerGroup interface{}) *MockActionsService_GetRunnerGroupByName_Call {
	return &MockActionsService_GetRunnerGroupByName_Call{Call: _e.mock.On("GetRunnerGroupByName", ctx, runnerGroup)}
}

func (_c *MockActionsService_GetRunnerGroupByName_Call) Run(run func(ctx context.Context, runnerGroup string)) *MockActionsService_GetRunnerGroupByName_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 string
		if args[1] != nil {
			arg1 = args[1].(string)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *MockActionsService_GetRunnerGroupByName_Call) Return(runnerGroup1 *RunnerGroup, err error) *MockActionsService_GetRunnerGroupByName_Call {
	_c.Call.Return(runnerGroup1, err)
	return _c
}

func (_c *MockActionsService_GetRunnerGroupByName_Call) RunAndReturn(run func(ctx context.Context, runnerGroup string) (*RunnerGroup, error)) *MockActionsService_GetRunnerGroupByName_Call {
	_c.Call.Return(run)
	return _c
}

// GetRunnerScaleSet provides a mock function for the type MockActionsService
func (_mock *MockActionsService) GetRunnerScaleSet(ctx context.Context, runnerGroupId int, runnerScaleSetName string) (*RunnerScaleSet, error) {
	ret := _mock.Called(ctx, runnerGroupId, runnerScaleSetName)

	if len(ret) == 0 {
		panic("no return value specified for GetRunnerScaleSet")
	}

	var r0 *RunnerScaleSet
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, int, string) (*RunnerScaleSet, error)); ok {
		return returnFunc(ctx, runnerGroupId, runnerScaleSetName)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, int, string) *RunnerScaleSet); ok {
		r0 = returnFunc(ctx, runnerGroupId, runnerScaleSetName)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*RunnerScaleSet)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, int, string) error); ok {
		r1 = returnFunc(ctx, runnerGroupId, runnerScaleSetName)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// MockActionsService_GetRunnerScaleSet_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetRunnerScaleSet'
type MockActionsService_GetRunnerScaleSet_Call struct {
	*mock.Call
}

// GetRunnerScaleSet is a helper method to define mock.On call
//   - ctx context.Context
//   - runnerGroupId int
//   - runnerScaleSetName string
func (_e *MockActionsService_Expecter) GetRunnerScaleSet(ctx interface{}, runnerGroupId interface{}, runnerScaleSetName interface{}) *MockActionsService_GetRunnerScaleSet_Call {
	return &MockActionsService_GetRunnerScaleSet_Call{Call: _e.mock.On("GetRunnerScaleSet", ctx, runnerGroupId, runnerScaleSetName)}
}

func (_c *MockActionsService_GetRunnerScaleSet_Call) Run(run func(ctx context.Context, runnerGroupId int, runnerScaleSetName string)) *MockActionsService_GetRunnerScaleSet_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 int
		if args[1] != nil {
			arg1 = args[1].(int)
		}
		var arg2 string
		if args[2] != nil {
			arg2 = args[2].(string)
		}
		run(
			arg0,
			arg1,
			arg2,
		)
	})
	return _c
}

func (_c *MockActionsService_GetRunnerScaleSet_Call) Return(runnerScaleSet *RunnerScaleSet, err error) *MockActionsService_GetRunnerScaleSet_Call {
	_c.Call.Return(runnerScaleSet, err)
	return _c
}

func (_c *MockActionsService_GetRunnerScaleSet_Call) RunAndReturn(run func(ctx context.Context, runnerGroupId int, runnerScaleSetName string) (*RunnerScaleSet, error)) *MockActionsService_GetRunnerScaleSet_Call {
	_c.Call.Return(run)
	return _c
}

// GetRunnerScaleSetById provides a mock function for the type MockActionsService
func (_mock *MockActionsService) GetRunnerScaleSetById(ctx context.Context, runnerScaleSetId int) (*RunnerScaleSet, error) {
	ret := _mock.Called(ctx, runnerScaleSetId)

	if len(ret) == 0 {
		panic("no return value specified for GetRunnerScaleSetById")
	}

	var r0 *RunnerScaleSet
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, int) (*RunnerScaleSet, error)); ok {
		return returnFunc(ctx, runnerScaleSetId)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, int) *RunnerScaleSet); ok {
		r0 = returnFunc(ctx, runnerScaleSetId)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*RunnerScaleSet)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, int) error); ok {
		r1 = returnFunc(ctx, runnerScaleSetId)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// MockActionsService_GetRunnerScaleSetById_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetRunnerScaleSetById'
type MockActionsService_GetRunnerScaleSetById_Call struct {
	*mock.Call
}

// GetRunnerScaleSetById is a helper method to define mock.On call
//   - ctx context.Context
//   - runnerScaleSetId int
func (_e *MockActionsService_Expecter) GetRunnerScaleSetById(ctx interface{}, runnerScaleSetId interface{}) *MockActionsService_GetRunnerScaleSetById_Call {
	return &MockActionsService_GetRunnerScaleSetById_Call{Call: _e.mock.On("GetRunnerScaleSetById", ctx, runnerScaleSetId)}
}

func (_c *MockActionsService_GetRunnerScaleSetById_Call) Run(run func(ctx context.Context, runnerScaleSetId int)) *MockActionsService_GetRunnerScaleSetById_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 int
		if args[1] != nil {
			arg1 = args[1].(int)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *MockActionsService_GetRunnerScaleSetById_Call) Return(runnerScaleSet *RunnerScaleSet, err error) *MockActionsService_GetRunnerScaleSetById_Call {
	_c.Call.Return(runnerScaleSet, err)
	return _c
}

func (_c *MockActionsService_GetRunnerScaleSetById_Call) RunAndReturn(run func(ctx context.Context, runnerScaleSetId int) (*RunnerScaleSet, error)) *MockActionsService_GetRunnerScaleSetById_Call {
	_c.Call.Return(run)
	return _c
}

// RefreshMessageSession provides a mock function for the type MockActionsService
func (_mock *MockActionsService) RefreshMessageSession(ctx context.Context, runnerScaleSetId int, sessionId *uuid.UUID) (*RunnerScaleSetSession, error) {
	ret := _mock.Called(ctx, runnerScaleSetId, sessionId)

	if len(ret) == 0 {
		panic("no return value specified for RefreshMessageSession")
	}

	var r0 *RunnerScaleSetSession
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, int, *uuid.UUID) (*RunnerScaleSetSession, error)); ok {
		return returnFunc(ctx, runnerScaleSetId, sessionId)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, int, *uuid.UUID) *RunnerScaleSetSession); ok {
		r0 = returnFunc(ctx, runnerScaleSetId, sessionId)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*RunnerScaleSetSession)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, int, *uuid.UUID) error); ok {
		r1 = returnFunc(ctx, runnerScaleSetId, sessionId)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// MockActionsService_RefreshMessageSession_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RefreshMessageSession'
type MockActionsService_RefreshMessageSession_Call struct {
	*mock.Call
}

// RefreshMessageSession is a helper method to define mock.On call
//   - ctx context.Context
//   - runnerScaleSetId int
//   - sessionId *uuid.UUID
func (_e *MockActionsService_Expecter) RefreshMessageSession(ctx interface{}, runnerScaleSetId interface{}, sessionId interface{}) *MockActionsService_RefreshMessageSession_Call {
	return &MockActionsService_RefreshMessageSession_Call{Call: _e.mock.On("RefreshMessageSession", ctx, runnerScaleSetId, sessionId)}
}

func (_c *MockActionsService_RefreshMessageSession_Call) Run(run func(ctx context.Context, runnerScaleSetId int, sessionId *uuid.UUID)) *MockActionsService_RefreshMessageSession_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 int
		if args[1] != nil {
			arg1 = args[1].(int)
		}
		var arg2 *uuid.UUID
		if args[2] != nil {
			arg2 = args[2].(*uuid.UUID)
		}
		run(
			arg0,
			arg1,
			arg2,
		)
	})
	return _c
}

func (_c *MockActionsService_RefreshMessageSession_Call) Return(runnerScaleSetSession *RunnerScaleSetSession, err error) *MockActionsService_RefreshMessageSession_Call {
	_c.Call.Return(runnerScaleSetSession, err)
	return _c
}

func (_c *MockActionsService_RefreshMessageSession_Call) RunAndReturn(run func(ctx context.Context, runnerScaleSetId int, sessionId *uuid.UUID) (*RunnerScaleSetSession, error)) *MockActionsService_RefreshMessageSession_Call {
	_c.Call.Return(run)
	return _c
}

// RemoveRunner provides a mock function for the type MockActionsService
func (_mock *MockActionsService) RemoveRunner(ctx context.Context, runnerId int64) error {
	ret := _mock.Called(ctx, runnerId)

	if len(ret) == 0 {
		panic("no return value specified for RemoveRunner")
	}

	var r0 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, int64) error); ok {
		r0 = returnFunc(ctx, runnerId)
	} else {
		r0 = ret.Error(0)
	}
	return r0
}

// MockActionsService_RemoveRunner_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RemoveRunner'
type MockActionsService_RemoveRunner_Call struct {
	*mock.Call
}

// RemoveRunner is a helper method to define mock.On call
//   - ctx context.Context
//   - runnerId int64
func (_e *MockActionsService_Expecter) RemoveRunner(ctx interface{}, runnerId interface{}) *MockActionsService_RemoveRunner_Call {
	return &MockActionsService_RemoveRunner_Call{Call: _e.mock.On("RemoveRunner", ctx, runnerId)}
}

func (_c *MockActionsService_RemoveRunner_Call) Run(run func(ctx context.Context, runnerId int64)) *MockActionsService_RemoveRunner_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 int64
		if args[1] != nil {
			arg1 = args[1].(int64)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *MockActionsService_RemoveRunner_Call) Return(err error) *MockActionsService_RemoveRunner_Call {
	_c.Call.Return(err)
	return _c
}

func (_c *MockActionsService_RemoveRunner_Call) RunAndReturn(run func(ctx context.Context, runnerId int64) error) *MockActionsService_RemoveRunner_Call {
	_c.Call.Return(run)
	return _c
}

// SetUserAgent provides a mock function for the type MockActionsService
func (_mock *MockActionsService) SetUserAgent(info UserAgentInfo) {
	_mock.Called(info)
	return
}

// MockActionsService_SetUserAgent_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetUserAgent'
type MockActionsService_SetUserAgent_Call struct {
	*mock.Call
}

// SetUserAgent is a helper method to define mock.On call
//   - info UserAgentInfo
func (_e *MockActionsService_Expecter) SetUserAgent(info interface{}) *MockActionsService_SetUserAgent_Call {
	return &MockActionsService_SetUserAgent_Call{Call: _e.mock.On("SetUserAgent", info)}
}

func (_c *MockActionsService_SetUserAgent_Call) Run(run func(info UserAgentInfo)) *MockActionsService_SetUserAgent_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 UserAgentInfo
		if args[0] != nil {
			arg0 = args[0].(UserAgentInfo)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *MockActionsService_SetUserAgent_Call) Return() *MockActionsService_SetUserAgent_Call {
	_c.Call.Return()
	return _c
}

func (_c *MockActionsService_SetUserAgent_Call) RunAndReturn(run func(info UserAgentInfo)) *MockActionsService_SetUserAgent_Call {
	_c.Run(run)
	return _c
}

// UpdateRunnerScaleSet provides a mock function for the type MockActionsService
func (_mock *MockActionsService) UpdateRunnerScaleSet(ctx context.Context, runnerScaleSetId int, runnerScaleSet *RunnerScaleSet) (*RunnerScaleSet, error) {
	ret := _mock.Called(ctx, runnerScaleSetId, runnerScaleSet)

	if len(ret) == 0 {
		panic("no return value specified for UpdateRunnerScaleSet")
	}

	var r0 *RunnerScaleSet
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, int, *RunnerScaleSet) (*RunnerScaleSet, error)); ok {
		return returnFunc(ctx, runnerScaleSetId, runnerScaleSet)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, int, *RunnerScaleSet) *RunnerScaleSet); ok {
		r0 = returnFunc(ctx, runnerScaleSetId, runnerScaleSet)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*RunnerScaleSet)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, int, *RunnerScaleSet) error); ok {
		r1 = returnFunc(ctx, runnerScaleSetId, runnerScaleSet)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// MockActionsService_UpdateRunnerScaleSet_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdateRunnerScaleSet'
type MockActionsService_UpdateRunnerScaleSet_Call struct {
	*mock.Call
}

// UpdateRunnerScaleSet is a helper method to define mock.On call
//   - ctx context.Context
//   - runnerScaleSetId int
//   - runnerScaleSet *RunnerScaleSet
func (_e *MockActionsService_Expecter) UpdateRunnerScaleSet(ctx interface{}, runnerScaleSetId interface{}, runnerScaleSet interface{}) *MockActionsService_UpdateRunnerScaleSet_Call {
	return &MockActionsService_UpdateRunnerScaleSet_Call{Call: _e.mock.On("UpdateRunnerScaleSet", ctx, runnerScaleSetId, runnerScaleSet)}
}

func (_c *MockActionsService_UpdateRunnerScaleSet_Call) Run(run func(ctx context.Context, runnerScaleSetId int, runnerScaleSet *RunnerScaleSet)) *MockActionsService_UpdateRunnerScaleSet_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 int
		if args[1] != nil {
			arg1 = args[1].(int)
		}
		var arg2 *RunnerScaleSet
		if args[2] != nil {
			arg2 = args[2].(*RunnerScaleSet)
		}
		run(
			arg0,
			arg1,
			arg2,
		)
	})
	return _c
}

func (_c *MockActionsService_UpdateRunnerScaleSet_Call) Return(runnerScaleSet1 *RunnerScaleSet, err error) *MockActionsService_UpdateRunnerScaleSet_Call {
	_c.Call.Return(runnerScaleSet1, err)
	return _c
}

func (_c *MockActionsService_UpdateRunnerScaleSet_Call) RunAndReturn(run func(ctx context.Context, runnerScaleSetId int, runnerScaleSet *RunnerScaleSet) (*RunnerScaleSet, error)) *MockActionsService_UpdateRunnerScaleSet_Call {
	_c.Call.Return(run)
	return _c
}

// NewMockSessionService creates a new instance of MockSessionService. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
// The first argument is typically a *testing.T value.
func NewMockSessionService(t interface {
	mock.TestingT
	Cleanup(func())
}) *MockSessionService {
	mock := &MockSessionService{}
	mock.Mock.Test(t)

	t.Cleanup(func() { mock.AssertExpectations(t) })

	return mock
}

// MockSessionService is an autogenerated mock type for the SessionService type
type MockSessionService struct {
	mock.Mock
}

type MockSessionService_Expecter struct {
	mock *mock.Mock
}

func (_m *MockSessionService) EXPECT() *MockSessionService_Expecter {
	return &MockSessionService_Expecter{mock: &_m.Mock}
}

// AcquireJobs provides a mock function for the type MockSessionService
func (_mock *MockSessionService) AcquireJobs(ctx context.Context, requestIds []int64) ([]int64, error) {
	ret := _mock.Called(ctx, requestIds)

	if len(ret) == 0 {
		panic("no return value specified for AcquireJobs")
	}

	var r0 []int64
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, []int64) ([]int64, error)); ok {
		return returnFunc(ctx, requestIds)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, []int64) []int64); ok {
		r0 = returnFunc(ctx, requestIds)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]int64)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, []int64) error); ok {
		r1 = returnFunc(ctx, requestIds)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// MockSessionService_AcquireJobs_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AcquireJobs'
type MockSessionService_AcquireJobs_Call struct {
	*mock.Call
}

// AcquireJobs is a helper method to define mock.On call
//   - ctx context.Context
//   - requestIds []int64
func (_e *MockSessionService_Expecter) AcquireJobs(ctx interface{}, requestIds interface{}) *MockSessionService_AcquireJobs_Call {
	return &MockSessionService_AcquireJobs_Call{Call: _e.mock.On("AcquireJobs", ctx, requestIds)}
}

func (_c *MockSessionService_AcquireJobs_Call) Run(run func(ctx context.Context, requestIds []int64)) *MockSessionService_AcquireJobs_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 []int64
		if args[1] != nil {
			arg1 = args[1].([]int64)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *MockSessionService_AcquireJobs_Call) Return(int64s []int64, err error) *MockSessionService_AcquireJobs_Call {
	_c.Call.Return(int64s, err)
	return _c
}

func (_c *MockSessionService_AcquireJobs_Call) RunAndReturn(run func(ctx context.Context, requestIds []int64) ([]int64, error)) *MockSessionService_AcquireJobs_Call {
	_c.Call.Return(run)
	return _c
}

// Close provides a mock function for the type MockSessionService
func (_mock *MockSessionService) Close() error {
	ret := _mock.Called()

	if len(ret) == 0 {
		panic("no return value specified for Close")
	}

	var r0 error
	if returnFunc, ok := ret.Get(0).(func() error); ok {
		r0 = returnFunc()
	} else {
		r0 = ret.Error(0)
	}
	return r0
}

// MockSessionService_Close_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Close'
type MockSessionService_Close_Call struct {
	*mock.Call
}

// Close is a helper method to define mock.On call
func (_e *MockSessionService_Expecter) Close() *MockSessionService_Close_Call {
	return &MockSessionService_Close_Call{Call: _e.mock.On("Close")}
}

func (_c *MockSessionService_Close_Call) Run(run func()) *MockSessionService_Close_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run()
	})
	return _c
}

func (_c *MockSessionService_Close_Call) Return(err error) *MockSessionService_Close_Call {
	_c.Call.Return(err)
	return _c
}

func (_c *MockSessionService_Close_Call) RunAndReturn(run func() error) *MockSessionService_Close_Call {
	_c.Call.Return(run)
	return _c
}

// DeleteMessage provides a mock function for the type MockSessionService
func (_mock *MockSessionService) DeleteMessage(ctx context.Context, messageId int64) error {
	ret := _mock.Called(ctx, messageId)

	if len(ret) == 0 {
		panic("no return value specified for DeleteMessage")
	}

	var r0 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, int64) error); ok {
		r0 = returnFunc(ctx, messageId)
	} else {
		r0 = ret.Error(0)
	}
	return r0
}

// MockSessionService_DeleteMessage_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteMessage'
type MockSessionService_DeleteMessage_Call struct {
	*mock.Call
}

// DeleteMessage is a helper method to define mock.On call
//   - ctx context.Context
//   - messageId int64
func (_e *MockSessionService_Expecter) DeleteMessage(ctx interface{}, messageId interface{}) *MockSessionService_DeleteMessage_Call {
	return &MockSessionService_DeleteMessage_Call{Call: _e.mock.On("DeleteMessage", ctx, messageId)}
}

func (_c *MockSessionService_DeleteMessage_Call) Run(run func(ctx context.Context, messageId int64)) *MockSessionService_DeleteMessage_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 int64
		if args[1] != nil {
			arg1 = args[1].(int64)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *MockSessionService_DeleteMessage_Call) Return(err error) *MockSessionService_DeleteMessage_Call {
	_c.Call.Return(err)
	return _c
}

func (_c *MockSessionService_DeleteMessage_Call) RunAndReturn(run func(ctx context.Context, messageId int64) error) *MockSessionService_DeleteMessage_Call {
	_c.Call.Return(run)
	return _c
}

// GetMessage provides a mock function for the type MockSessionService
func (_mock *MockSessionService) GetMessage(ctx context.Context, lastMessageId int64, maxCapacity int) (*RunnerScaleSetMessage, error) {
	ret := _mock.Called(ctx, lastMessageId, maxCapacity)

	if len(ret) == 0 {
		panic("no return value specified for GetMessage")
	}

	var r0 *RunnerScaleSetMessage
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, int64, int) (*RunnerScaleSetMessage, error)); ok {
		return returnFunc(ctx, lastMessageId, maxCapacity)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, int64, int) *RunnerScaleSetMessage); ok {
		r0 = returnFunc(ctx, lastMessageId, maxCapacity)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*RunnerScaleSetMessage)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, int64, int) error); ok {
		r1 = returnFunc(ctx, lastMessageId, maxCapacity)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// MockSessionService_GetMessage_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetMessage'
type MockSessionService_GetMessage_Call struct {
	*mock.Call
}

// GetMessage is a helper method to define mock.On call
//   - ctx context.Context
//   - lastMessageId int64
//   - maxCapacity int
func (_e *MockSessionService_Expecter) GetMessage(ctx interface{}, lastMessageId interface{}, maxCapacity interface{}) *MockSessionService_GetMessage_Call {
	return &MockSessionService_GetMessage_Call{Call: _e.mock.On("GetMessage", ctx, lastMessageId, maxCapacity)}
}

func (_c *MockSessionService_GetMessage_Call) Run(run func(ctx context.Context, lastMessageId int64, maxCapacity int)) *MockSessionService_GetMessage_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 int64
		if args[1] != nil {
			arg1 = args[1].(int64)
		}
		var arg2 int
		if args[2] != nil {
			arg2 = args[2].(int)
		}
		run(
			arg0,
			arg1,
			arg2,
		)
	})
	return _c
}

func (_c *MockSessionService_GetMessage_Call) Return(runnerScaleSetMessage *RunnerScaleSetMessage, err error) *MockSessionService_GetMessage_Call {
	_c.Call.Return(runnerScaleSetMessage, err)
	return _c
}

func (_c *MockSessionService_GetMessage_Call) RunAndReturn(run func(ctx context.Context, lastMessageId int64, maxCapacity int) (*RunnerScaleSetMessage, error)) *MockSessionService_GetMessage_Call {
	_c.Call.Return(run)
	return _c
}
