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

package mocks_cups_pkhelper

import (
	"github.com/AvengeMedia/DankMaterialShell/core/internal/server/cups"
	mock "github.com/stretchr/testify/mock"
)

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

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

	return mock
}

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

type MockPkHelper_Expecter struct {
	mock *mock.Mock
}

func (_m *MockPkHelper) EXPECT() *MockPkHelper_Expecter {
	return &MockPkHelper_Expecter{mock: &_m.Mock}
}

// ClassAddPrinter provides a mock function for the type MockPkHelper
func (_mock *MockPkHelper) ClassAddPrinter(className string, printerName string) error {
	ret := _mock.Called(className, printerName)

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

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

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

// ClassAddPrinter is a helper method to define mock.On call
//   - className string
//   - printerName string
func (_e *MockPkHelper_Expecter) ClassAddPrinter(className any, printerName any) *MockPkHelper_ClassAddPrinter_Call {
	return &MockPkHelper_ClassAddPrinter_Call{Call: _e.mock.On("ClassAddPrinter", className, printerName)}
}

func (_c *MockPkHelper_ClassAddPrinter_Call) Run(run func(className string, printerName string)) *MockPkHelper_ClassAddPrinter_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 string
		if args[0] != nil {
			arg0 = args[0].(string)
		}
		var arg1 string
		if args[1] != nil {
			arg1 = args[1].(string)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

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

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

// ClassDelete provides a mock function for the type MockPkHelper
func (_mock *MockPkHelper) ClassDelete(className string) error {
	ret := _mock.Called(className)

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

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

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

// ClassDelete is a helper method to define mock.On call
//   - className string
func (_e *MockPkHelper_Expecter) ClassDelete(className any) *MockPkHelper_ClassDelete_Call {
	return &MockPkHelper_ClassDelete_Call{Call: _e.mock.On("ClassDelete", className)}
}

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

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

func (_c *MockPkHelper_ClassDelete_Call) RunAndReturn(run func(className string) error) *MockPkHelper_ClassDelete_Call {
	_c.Call.Return(run)
	return _c
}

// ClassDeletePrinter provides a mock function for the type MockPkHelper
func (_mock *MockPkHelper) ClassDeletePrinter(className string, printerName string) error {
	ret := _mock.Called(className, printerName)

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

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

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

// ClassDeletePrinter is a helper method to define mock.On call
//   - className string
//   - printerName string
func (_e *MockPkHelper_Expecter) ClassDeletePrinter(className any, printerName any) *MockPkHelper_ClassDeletePrinter_Call {
	return &MockPkHelper_ClassDeletePrinter_Call{Call: _e.mock.On("ClassDeletePrinter", className, printerName)}
}

func (_c *MockPkHelper_ClassDeletePrinter_Call) Run(run func(className string, printerName string)) *MockPkHelper_ClassDeletePrinter_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 string
		if args[0] != nil {
			arg0 = args[0].(string)
		}
		var arg1 string
		if args[1] != nil {
			arg1 = args[1].(string)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

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

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

// DevicesGet provides a mock function for the type MockPkHelper
func (_mock *MockPkHelper) DevicesGet(timeout int, limit int, includeSchemes []string, excludeSchemes []string) ([]cups.Device, error) {
	ret := _mock.Called(timeout, limit, includeSchemes, excludeSchemes)

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

	var r0 []cups.Device
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(int, int, []string, []string) ([]cups.Device, error)); ok {
		return returnFunc(timeout, limit, includeSchemes, excludeSchemes)
	}
	if returnFunc, ok := ret.Get(0).(func(int, int, []string, []string) []cups.Device); ok {
		r0 = returnFunc(timeout, limit, includeSchemes, excludeSchemes)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]cups.Device)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(int, int, []string, []string) error); ok {
		r1 = returnFunc(timeout, limit, includeSchemes, excludeSchemes)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// DevicesGet is a helper method to define mock.On call
//   - timeout int
//   - limit int
//   - includeSchemes []string
//   - excludeSchemes []string
func (_e *MockPkHelper_Expecter) DevicesGet(timeout any, limit any, includeSchemes any, excludeSchemes any) *MockPkHelper_DevicesGet_Call {
	return &MockPkHelper_DevicesGet_Call{Call: _e.mock.On("DevicesGet", timeout, limit, includeSchemes, excludeSchemes)}
}

func (_c *MockPkHelper_DevicesGet_Call) Run(run func(timeout int, limit int, includeSchemes []string, excludeSchemes []string)) *MockPkHelper_DevicesGet_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 int
		if args[0] != nil {
			arg0 = args[0].(int)
		}
		var arg1 int
		if args[1] != nil {
			arg1 = args[1].(int)
		}
		var arg2 []string
		if args[2] != nil {
			arg2 = args[2].([]string)
		}
		var arg3 []string
		if args[3] != nil {
			arg3 = args[3].([]string)
		}
		run(
			arg0,
			arg1,
			arg2,
			arg3,
		)
	})
	return _c
}

func (_c *MockPkHelper_DevicesGet_Call) Return(devices []cups.Device, err error) *MockPkHelper_DevicesGet_Call {
	_c.Call.Return(devices, err)
	return _c
}

func (_c *MockPkHelper_DevicesGet_Call) RunAndReturn(run func(timeout int, limit int, includeSchemes []string, excludeSchemes []string) ([]cups.Device, error)) *MockPkHelper_DevicesGet_Call {
	_c.Call.Return(run)
	return _c
}

// JobCancelPurge provides a mock function for the type MockPkHelper
func (_mock *MockPkHelper) JobCancelPurge(jobID int, purge bool) error {
	ret := _mock.Called(jobID, purge)

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

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

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

// JobCancelPurge is a helper method to define mock.On call
//   - jobID int
//   - purge bool
func (_e *MockPkHelper_Expecter) JobCancelPurge(jobID any, purge any) *MockPkHelper_JobCancelPurge_Call {
	return &MockPkHelper_JobCancelPurge_Call{Call: _e.mock.On("JobCancelPurge", jobID, purge)}
}

func (_c *MockPkHelper_JobCancelPurge_Call) Run(run func(jobID int, purge bool)) *MockPkHelper_JobCancelPurge_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 int
		if args[0] != nil {
			arg0 = args[0].(int)
		}
		var arg1 bool
		if args[1] != nil {
			arg1 = args[1].(bool)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

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

func (_c *MockPkHelper_JobCancelPurge_Call) RunAndReturn(run func(jobID int, purge bool) error) *MockPkHelper_JobCancelPurge_Call {
	_c.Call.Return(run)
	return _c
}

// JobRestart provides a mock function for the type MockPkHelper
func (_mock *MockPkHelper) JobRestart(jobID int) error {
	ret := _mock.Called(jobID)

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

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

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

// JobRestart is a helper method to define mock.On call
//   - jobID int
func (_e *MockPkHelper_Expecter) JobRestart(jobID any) *MockPkHelper_JobRestart_Call {
	return &MockPkHelper_JobRestart_Call{Call: _e.mock.On("JobRestart", jobID)}
}

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

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

func (_c *MockPkHelper_JobRestart_Call) RunAndReturn(run func(jobID int) error) *MockPkHelper_JobRestart_Call {
	_c.Call.Return(run)
	return _c
}

// JobSetHoldUntil provides a mock function for the type MockPkHelper
func (_mock *MockPkHelper) JobSetHoldUntil(jobID int, holdUntil string) error {
	ret := _mock.Called(jobID, holdUntil)

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

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

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

// JobSetHoldUntil is a helper method to define mock.On call
//   - jobID int
//   - holdUntil string
func (_e *MockPkHelper_Expecter) JobSetHoldUntil(jobID any, holdUntil any) *MockPkHelper_JobSetHoldUntil_Call {
	return &MockPkHelper_JobSetHoldUntil_Call{Call: _e.mock.On("JobSetHoldUntil", jobID, holdUntil)}
}

func (_c *MockPkHelper_JobSetHoldUntil_Call) Run(run func(jobID int, holdUntil string)) *MockPkHelper_JobSetHoldUntil_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 int
		if args[0] != nil {
			arg0 = args[0].(int)
		}
		var arg1 string
		if args[1] != nil {
			arg1 = args[1].(string)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

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

func (_c *MockPkHelper_JobSetHoldUntil_Call) RunAndReturn(run func(jobID int, holdUntil string) error) *MockPkHelper_JobSetHoldUntil_Call {
	_c.Call.Return(run)
	return _c
}

// PrinterAdd provides a mock function for the type MockPkHelper
func (_mock *MockPkHelper) PrinterAdd(name string, uri string, ppd string, info string, location string) error {
	ret := _mock.Called(name, uri, ppd, info, location)

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

	var r0 error
	if returnFunc, ok := ret.Get(0).(func(string, string, string, string, string) error); ok {
		r0 = returnFunc(name, uri, ppd, info, location)
	} else {
		r0 = ret.Error(0)
	}
	return r0
}

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

// PrinterAdd is a helper method to define mock.On call
//   - name string
//   - uri string
//   - ppd string
//   - info string
//   - location string
func (_e *MockPkHelper_Expecter) PrinterAdd(name any, uri any, ppd any, info any, location any) *MockPkHelper_PrinterAdd_Call {
	return &MockPkHelper_PrinterAdd_Call{Call: _e.mock.On("PrinterAdd", name, uri, ppd, info, location)}
}

func (_c *MockPkHelper_PrinterAdd_Call) Run(run func(name string, uri string, ppd string, info string, location string)) *MockPkHelper_PrinterAdd_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 string
		if args[0] != nil {
			arg0 = args[0].(string)
		}
		var arg1 string
		if args[1] != nil {
			arg1 = args[1].(string)
		}
		var arg2 string
		if args[2] != nil {
			arg2 = args[2].(string)
		}
		var arg3 string
		if args[3] != nil {
			arg3 = args[3].(string)
		}
		var arg4 string
		if args[4] != nil {
			arg4 = args[4].(string)
		}
		run(
			arg0,
			arg1,
			arg2,
			arg3,
			arg4,
		)
	})
	return _c
}

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

func (_c *MockPkHelper_PrinterAdd_Call) RunAndReturn(run func(name string, uri string, ppd string, info string, location string) error) *MockPkHelper_PrinterAdd_Call {
	_c.Call.Return(run)
	return _c
}

// PrinterDelete provides a mock function for the type MockPkHelper
func (_mock *MockPkHelper) PrinterDelete(name string) error {
	ret := _mock.Called(name)

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

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

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

// PrinterDelete is a helper method to define mock.On call
//   - name string
func (_e *MockPkHelper_Expecter) PrinterDelete(name any) *MockPkHelper_PrinterDelete_Call {
	return &MockPkHelper_PrinterDelete_Call{Call: _e.mock.On("PrinterDelete", name)}
}

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

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

func (_c *MockPkHelper_PrinterDelete_Call) RunAndReturn(run func(name string) error) *MockPkHelper_PrinterDelete_Call {
	_c.Call.Return(run)
	return _c
}

// PrinterSetAcceptJobs provides a mock function for the type MockPkHelper
func (_mock *MockPkHelper) PrinterSetAcceptJobs(name string, enabled bool, reason string) error {
	ret := _mock.Called(name, enabled, reason)

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

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

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

// PrinterSetAcceptJobs is a helper method to define mock.On call
//   - name string
//   - enabled bool
//   - reason string
func (_e *MockPkHelper_Expecter) PrinterSetAcceptJobs(name any, enabled any, reason any) *MockPkHelper_PrinterSetAcceptJobs_Call {
	return &MockPkHelper_PrinterSetAcceptJobs_Call{Call: _e.mock.On("PrinterSetAcceptJobs", name, enabled, reason)}
}

func (_c *MockPkHelper_PrinterSetAcceptJobs_Call) Run(run func(name string, enabled bool, reason string)) *MockPkHelper_PrinterSetAcceptJobs_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 string
		if args[0] != nil {
			arg0 = args[0].(string)
		}
		var arg1 bool
		if args[1] != nil {
			arg1 = args[1].(bool)
		}
		var arg2 string
		if args[2] != nil {
			arg2 = args[2].(string)
		}
		run(
			arg0,
			arg1,
			arg2,
		)
	})
	return _c
}

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

func (_c *MockPkHelper_PrinterSetAcceptJobs_Call) RunAndReturn(run func(name string, enabled bool, reason string) error) *MockPkHelper_PrinterSetAcceptJobs_Call {
	_c.Call.Return(run)
	return _c
}

// PrinterSetEnabled provides a mock function for the type MockPkHelper
func (_mock *MockPkHelper) PrinterSetEnabled(name string, enabled bool) error {
	ret := _mock.Called(name, enabled)

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

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

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

// PrinterSetEnabled is a helper method to define mock.On call
//   - name string
//   - enabled bool
func (_e *MockPkHelper_Expecter) PrinterSetEnabled(name any, enabled any) *MockPkHelper_PrinterSetEnabled_Call {
	return &MockPkHelper_PrinterSetEnabled_Call{Call: _e.mock.On("PrinterSetEnabled", name, enabled)}
}

func (_c *MockPkHelper_PrinterSetEnabled_Call) Run(run func(name string, enabled bool)) *MockPkHelper_PrinterSetEnabled_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 string
		if args[0] != nil {
			arg0 = args[0].(string)
		}
		var arg1 bool
		if args[1] != nil {
			arg1 = args[1].(bool)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

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

func (_c *MockPkHelper_PrinterSetEnabled_Call) RunAndReturn(run func(name string, enabled bool) error) *MockPkHelper_PrinterSetEnabled_Call {
	_c.Call.Return(run)
	return _c
}

// PrinterSetInfo provides a mock function for the type MockPkHelper
func (_mock *MockPkHelper) PrinterSetInfo(name string, info string) error {
	ret := _mock.Called(name, info)

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

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

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

// PrinterSetInfo is a helper method to define mock.On call
//   - name string
//   - info string
func (_e *MockPkHelper_Expecter) PrinterSetInfo(name any, info any) *MockPkHelper_PrinterSetInfo_Call {
	return &MockPkHelper_PrinterSetInfo_Call{Call: _e.mock.On("PrinterSetInfo", name, info)}
}

func (_c *MockPkHelper_PrinterSetInfo_Call) Run(run func(name string, info string)) *MockPkHelper_PrinterSetInfo_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 string
		if args[0] != nil {
			arg0 = args[0].(string)
		}
		var arg1 string
		if args[1] != nil {
			arg1 = args[1].(string)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

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

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

// PrinterSetLocation provides a mock function for the type MockPkHelper
func (_mock *MockPkHelper) PrinterSetLocation(name string, location string) error {
	ret := _mock.Called(name, location)

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

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

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

// PrinterSetLocation is a helper method to define mock.On call
//   - name string
//   - location string
func (_e *MockPkHelper_Expecter) PrinterSetLocation(name any, location any) *MockPkHelper_PrinterSetLocation_Call {
	return &MockPkHelper_PrinterSetLocation_Call{Call: _e.mock.On("PrinterSetLocation", name, location)}
}

func (_c *MockPkHelper_PrinterSetLocation_Call) Run(run func(name string, location string)) *MockPkHelper_PrinterSetLocation_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 string
		if args[0] != nil {
			arg0 = args[0].(string)
		}
		var arg1 string
		if args[1] != nil {
			arg1 = args[1].(string)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

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

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

// PrinterSetShared provides a mock function for the type MockPkHelper
func (_mock *MockPkHelper) PrinterSetShared(name string, shared bool) error {
	ret := _mock.Called(name, shared)

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

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

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

// PrinterSetShared is a helper method to define mock.On call
//   - name string
//   - shared bool
func (_e *MockPkHelper_Expecter) PrinterSetShared(name any, shared any) *MockPkHelper_PrinterSetShared_Call {
	return &MockPkHelper_PrinterSetShared_Call{Call: _e.mock.On("PrinterSetShared", name, shared)}
}

func (_c *MockPkHelper_PrinterSetShared_Call) Run(run func(name string, shared bool)) *MockPkHelper_PrinterSetShared_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 string
		if args[0] != nil {
			arg0 = args[0].(string)
		}
		var arg1 bool
		if args[1] != nil {
			arg1 = args[1].(bool)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

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

func (_c *MockPkHelper_PrinterSetShared_Call) RunAndReturn(run func(name string, shared bool) error) *MockPkHelper_PrinterSetShared_Call {
	_c.Call.Return(run)
	return _c
}
