// Code generated by mockery. DO NOT EDIT.

package mocks

import (
	context "context"

	params "github.com/cloudbase/garm/params"
	mock "github.com/stretchr/testify/mock"
)

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

type PoolManager_Expecter struct {
	mock *mock.Mock
}

func (_m *PoolManager) EXPECT() *PoolManager_Expecter {
	return &PoolManager_Expecter{mock: &_m.Mock}
}

// GetWebhookInfo provides a mock function with given fields: ctx
func (_m *PoolManager) GetWebhookInfo(ctx context.Context) (params.HookInfo, error) {
	ret := _m.Called(ctx)

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

	var r0 params.HookInfo
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context) (params.HookInfo, error)); ok {
		return rf(ctx)
	}
	if rf, ok := ret.Get(0).(func(context.Context) params.HookInfo); ok {
		r0 = rf(ctx)
	} else {
		r0 = ret.Get(0).(params.HookInfo)
	}

	if rf, ok := ret.Get(1).(func(context.Context) error); ok {
		r1 = rf(ctx)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// GetWebhookInfo is a helper method to define mock.On call
//   - ctx context.Context
func (_e *PoolManager_Expecter) GetWebhookInfo(ctx interface{}) *PoolManager_GetWebhookInfo_Call {
	return &PoolManager_GetWebhookInfo_Call{Call: _e.mock.On("GetWebhookInfo", ctx)}
}

func (_c *PoolManager_GetWebhookInfo_Call) Run(run func(ctx context.Context)) *PoolManager_GetWebhookInfo_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context))
	})
	return _c
}

func (_c *PoolManager_GetWebhookInfo_Call) Return(_a0 params.HookInfo, _a1 error) *PoolManager_GetWebhookInfo_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *PoolManager_GetWebhookInfo_Call) RunAndReturn(run func(context.Context) (params.HookInfo, error)) *PoolManager_GetWebhookInfo_Call {
	_c.Call.Return(run)
	return _c
}

// GithubRunnerRegistrationToken provides a mock function with no fields
func (_m *PoolManager) GithubRunnerRegistrationToken() (string, error) {
	ret := _m.Called()

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

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

	if rf, ok := ret.Get(1).(func() error); ok {
		r1 = rf()
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// GithubRunnerRegistrationToken is a helper method to define mock.On call
func (_e *PoolManager_Expecter) GithubRunnerRegistrationToken() *PoolManager_GithubRunnerRegistrationToken_Call {
	return &PoolManager_GithubRunnerRegistrationToken_Call{Call: _e.mock.On("GithubRunnerRegistrationToken")}
}

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

func (_c *PoolManager_GithubRunnerRegistrationToken_Call) Return(_a0 string, _a1 error) *PoolManager_GithubRunnerRegistrationToken_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *PoolManager_GithubRunnerRegistrationToken_Call) RunAndReturn(run func() (string, error)) *PoolManager_GithubRunnerRegistrationToken_Call {
	_c.Call.Return(run)
	return _c
}

// HandleWorkflowJob provides a mock function with given fields: job
func (_m *PoolManager) HandleWorkflowJob(job params.WorkflowJob) error {
	ret := _m.Called(job)

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

	var r0 error
	if rf, ok := ret.Get(0).(func(params.WorkflowJob) error); ok {
		r0 = rf(job)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

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

// HandleWorkflowJob is a helper method to define mock.On call
//   - job params.WorkflowJob
func (_e *PoolManager_Expecter) HandleWorkflowJob(job interface{}) *PoolManager_HandleWorkflowJob_Call {
	return &PoolManager_HandleWorkflowJob_Call{Call: _e.mock.On("HandleWorkflowJob", job)}
}

func (_c *PoolManager_HandleWorkflowJob_Call) Run(run func(job params.WorkflowJob)) *PoolManager_HandleWorkflowJob_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(params.WorkflowJob))
	})
	return _c
}

func (_c *PoolManager_HandleWorkflowJob_Call) Return(_a0 error) *PoolManager_HandleWorkflowJob_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *PoolManager_HandleWorkflowJob_Call) RunAndReturn(run func(params.WorkflowJob) error) *PoolManager_HandleWorkflowJob_Call {
	_c.Call.Return(run)
	return _c
}

// ID provides a mock function with no fields
func (_m *PoolManager) ID() string {
	ret := _m.Called()

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

	var r0 string
	if rf, ok := ret.Get(0).(func() string); ok {
		r0 = rf()
	} else {
		r0 = ret.Get(0).(string)
	}

	return r0
}

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

// ID is a helper method to define mock.On call
func (_e *PoolManager_Expecter) ID() *PoolManager_ID_Call {
	return &PoolManager_ID_Call{Call: _e.mock.On("ID")}
}

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

func (_c *PoolManager_ID_Call) Return(_a0 string) *PoolManager_ID_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *PoolManager_ID_Call) RunAndReturn(run func() string) *PoolManager_ID_Call {
	_c.Call.Return(run)
	return _c
}

// InstallWebhook provides a mock function with given fields: ctx, param
func (_m *PoolManager) InstallWebhook(ctx context.Context, param params.InstallWebhookParams) (params.HookInfo, error) {
	ret := _m.Called(ctx, param)

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

	var r0 params.HookInfo
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, params.InstallWebhookParams) (params.HookInfo, error)); ok {
		return rf(ctx, param)
	}
	if rf, ok := ret.Get(0).(func(context.Context, params.InstallWebhookParams) params.HookInfo); ok {
		r0 = rf(ctx, param)
	} else {
		r0 = ret.Get(0).(params.HookInfo)
	}

	if rf, ok := ret.Get(1).(func(context.Context, params.InstallWebhookParams) error); ok {
		r1 = rf(ctx, param)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// InstallWebhook is a helper method to define mock.On call
//   - ctx context.Context
//   - param params.InstallWebhookParams
func (_e *PoolManager_Expecter) InstallWebhook(ctx interface{}, param interface{}) *PoolManager_InstallWebhook_Call {
	return &PoolManager_InstallWebhook_Call{Call: _e.mock.On("InstallWebhook", ctx, param)}
}

func (_c *PoolManager_InstallWebhook_Call) Run(run func(ctx context.Context, param params.InstallWebhookParams)) *PoolManager_InstallWebhook_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(params.InstallWebhookParams))
	})
	return _c
}

func (_c *PoolManager_InstallWebhook_Call) Return(_a0 params.HookInfo, _a1 error) *PoolManager_InstallWebhook_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *PoolManager_InstallWebhook_Call) RunAndReturn(run func(context.Context, params.InstallWebhookParams) (params.HookInfo, error)) *PoolManager_InstallWebhook_Call {
	_c.Call.Return(run)
	return _c
}

// RootCABundle provides a mock function with no fields
func (_m *PoolManager) RootCABundle() (params.CertificateBundle, error) {
	ret := _m.Called()

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

	var r0 params.CertificateBundle
	var r1 error
	if rf, ok := ret.Get(0).(func() (params.CertificateBundle, error)); ok {
		return rf()
	}
	if rf, ok := ret.Get(0).(func() params.CertificateBundle); ok {
		r0 = rf()
	} else {
		r0 = ret.Get(0).(params.CertificateBundle)
	}

	if rf, ok := ret.Get(1).(func() error); ok {
		r1 = rf()
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// RootCABundle is a helper method to define mock.On call
func (_e *PoolManager_Expecter) RootCABundle() *PoolManager_RootCABundle_Call {
	return &PoolManager_RootCABundle_Call{Call: _e.mock.On("RootCABundle")}
}

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

func (_c *PoolManager_RootCABundle_Call) Return(_a0 params.CertificateBundle, _a1 error) *PoolManager_RootCABundle_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *PoolManager_RootCABundle_Call) RunAndReturn(run func() (params.CertificateBundle, error)) *PoolManager_RootCABundle_Call {
	_c.Call.Return(run)
	return _c
}

// SetPoolRunningState provides a mock function with given fields: isRunning, failureReason
func (_m *PoolManager) SetPoolRunningState(isRunning bool, failureReason string) {
	_m.Called(isRunning, failureReason)
}

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

// SetPoolRunningState is a helper method to define mock.On call
//   - isRunning bool
//   - failureReason string
func (_e *PoolManager_Expecter) SetPoolRunningState(isRunning interface{}, failureReason interface{}) *PoolManager_SetPoolRunningState_Call {
	return &PoolManager_SetPoolRunningState_Call{Call: _e.mock.On("SetPoolRunningState", isRunning, failureReason)}
}

func (_c *PoolManager_SetPoolRunningState_Call) Run(run func(isRunning bool, failureReason string)) *PoolManager_SetPoolRunningState_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(bool), args[1].(string))
	})
	return _c
}

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

func (_c *PoolManager_SetPoolRunningState_Call) RunAndReturn(run func(bool, string)) *PoolManager_SetPoolRunningState_Call {
	_c.Run(run)
	return _c
}

// Start provides a mock function with no fields
func (_m *PoolManager) Start() error {
	ret := _m.Called()

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

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

	return r0
}

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

// Start is a helper method to define mock.On call
func (_e *PoolManager_Expecter) Start() *PoolManager_Start_Call {
	return &PoolManager_Start_Call{Call: _e.mock.On("Start")}
}

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

func (_c *PoolManager_Start_Call) Return(_a0 error) *PoolManager_Start_Call {
	_c.Call.Return(_a0)
	return _c
}

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

// Status provides a mock function with no fields
func (_m *PoolManager) Status() params.PoolManagerStatus {
	ret := _m.Called()

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

	var r0 params.PoolManagerStatus
	if rf, ok := ret.Get(0).(func() params.PoolManagerStatus); ok {
		r0 = rf()
	} else {
		r0 = ret.Get(0).(params.PoolManagerStatus)
	}

	return r0
}

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

// Status is a helper method to define mock.On call
func (_e *PoolManager_Expecter) Status() *PoolManager_Status_Call {
	return &PoolManager_Status_Call{Call: _e.mock.On("Status")}
}

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

func (_c *PoolManager_Status_Call) Return(_a0 params.PoolManagerStatus) *PoolManager_Status_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *PoolManager_Status_Call) RunAndReturn(run func() params.PoolManagerStatus) *PoolManager_Status_Call {
	_c.Call.Return(run)
	return _c
}

// Stop provides a mock function with no fields
func (_m *PoolManager) Stop() error {
	ret := _m.Called()

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

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

	return r0
}

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

// Stop is a helper method to define mock.On call
func (_e *PoolManager_Expecter) Stop() *PoolManager_Stop_Call {
	return &PoolManager_Stop_Call{Call: _e.mock.On("Stop")}
}

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

func (_c *PoolManager_Stop_Call) Return(_a0 error) *PoolManager_Stop_Call {
	_c.Call.Return(_a0)
	return _c
}

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

// UninstallWebhook provides a mock function with given fields: ctx
func (_m *PoolManager) UninstallWebhook(ctx context.Context) error {
	ret := _m.Called(ctx)

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

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

	return r0
}

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

// UninstallWebhook is a helper method to define mock.On call
//   - ctx context.Context
func (_e *PoolManager_Expecter) UninstallWebhook(ctx interface{}) *PoolManager_UninstallWebhook_Call {
	return &PoolManager_UninstallWebhook_Call{Call: _e.mock.On("UninstallWebhook", ctx)}
}

func (_c *PoolManager_UninstallWebhook_Call) Run(run func(ctx context.Context)) *PoolManager_UninstallWebhook_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context))
	})
	return _c
}

func (_c *PoolManager_UninstallWebhook_Call) Return(_a0 error) *PoolManager_UninstallWebhook_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *PoolManager_UninstallWebhook_Call) RunAndReturn(run func(context.Context) error) *PoolManager_UninstallWebhook_Call {
	_c.Call.Return(run)
	return _c
}

// Wait provides a mock function with no fields
func (_m *PoolManager) Wait() error {
	ret := _m.Called()

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

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

	return r0
}

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

// Wait is a helper method to define mock.On call
func (_e *PoolManager_Expecter) Wait() *PoolManager_Wait_Call {
	return &PoolManager_Wait_Call{Call: _e.mock.On("Wait")}
}

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

func (_c *PoolManager_Wait_Call) Return(_a0 error) *PoolManager_Wait_Call {
	_c.Call.Return(_a0)
	return _c
}

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

// WebhookSecret provides a mock function with no fields
func (_m *PoolManager) WebhookSecret() string {
	ret := _m.Called()

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

	var r0 string
	if rf, ok := ret.Get(0).(func() string); ok {
		r0 = rf()
	} else {
		r0 = ret.Get(0).(string)
	}

	return r0
}

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

// WebhookSecret is a helper method to define mock.On call
func (_e *PoolManager_Expecter) WebhookSecret() *PoolManager_WebhookSecret_Call {
	return &PoolManager_WebhookSecret_Call{Call: _e.mock.On("WebhookSecret")}
}

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

func (_c *PoolManager_WebhookSecret_Call) Return(_a0 string) *PoolManager_WebhookSecret_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *PoolManager_WebhookSecret_Call) RunAndReturn(run func() string) *PoolManager_WebhookSecret_Call {
	_c.Call.Return(run)
	return _c
}

// NewPoolManager creates a new instance of PoolManager. 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 NewPoolManager(t interface {
	mock.TestingT
	Cleanup(func())
}) *PoolManager {
	mock := &PoolManager{}
	mock.Mock.Test(t)

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

	return mock
}
