// Code generated by mockery v2.53.5. DO NOT EDIT.

package mocks_cups

import (
	io "io"

	ipp "github.com/AvengeMedia/DankMaterialShell/backend/pkg/ipp"
	mock "github.com/stretchr/testify/mock"
)

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

type MockCUPSClientInterface_Expecter struct {
	mock *mock.Mock
}

func (_m *MockCUPSClientInterface) EXPECT() *MockCUPSClientInterface_Expecter {
	return &MockCUPSClientInterface_Expecter{mock: &_m.Mock}
}

// CancelAllJob provides a mock function with given fields: printer, purge
func (_m *MockCUPSClientInterface) CancelAllJob(printer string, purge bool) error {
	ret := _m.Called(printer, purge)

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

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

	return r0
}

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

// CancelAllJob is a helper method to define mock.On call
//   - printer string
//   - purge bool
func (_e *MockCUPSClientInterface_Expecter) CancelAllJob(printer interface{}, purge interface{}) *MockCUPSClientInterface_CancelAllJob_Call {
	return &MockCUPSClientInterface_CancelAllJob_Call{Call: _e.mock.On("CancelAllJob", printer, purge)}
}

func (_c *MockCUPSClientInterface_CancelAllJob_Call) Run(run func(printer string, purge bool)) *MockCUPSClientInterface_CancelAllJob_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(string), args[1].(bool))
	})
	return _c
}

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

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

// CancelJob provides a mock function with given fields: jobID, purge
func (_m *MockCUPSClientInterface) CancelJob(jobID int, purge bool) error {
	ret := _m.Called(jobID, purge)

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

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

	return r0
}

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

// CancelJob is a helper method to define mock.On call
//   - jobID int
//   - purge bool
func (_e *MockCUPSClientInterface_Expecter) CancelJob(jobID interface{}, purge interface{}) *MockCUPSClientInterface_CancelJob_Call {
	return &MockCUPSClientInterface_CancelJob_Call{Call: _e.mock.On("CancelJob", jobID, purge)}
}

func (_c *MockCUPSClientInterface_CancelJob_Call) Run(run func(jobID int, purge bool)) *MockCUPSClientInterface_CancelJob_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(int), args[1].(bool))
	})
	return _c
}

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

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

// GetJobs provides a mock function with given fields: printer, class, whichJobs, myJobs, firstJobId, limit, attributes
func (_m *MockCUPSClientInterface) GetJobs(printer string, class string, whichJobs string, myJobs bool, firstJobId int, limit int, attributes []string) (map[int]ipp.Attributes, error) {
	ret := _m.Called(printer, class, whichJobs, myJobs, firstJobId, limit, attributes)

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

	var r0 map[int]ipp.Attributes
	var r1 error
	if rf, ok := ret.Get(0).(func(string, string, string, bool, int, int, []string) (map[int]ipp.Attributes, error)); ok {
		return rf(printer, class, whichJobs, myJobs, firstJobId, limit, attributes)
	}
	if rf, ok := ret.Get(0).(func(string, string, string, bool, int, int, []string) map[int]ipp.Attributes); ok {
		r0 = rf(printer, class, whichJobs, myJobs, firstJobId, limit, attributes)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(map[int]ipp.Attributes)
		}
	}

	if rf, ok := ret.Get(1).(func(string, string, string, bool, int, int, []string) error); ok {
		r1 = rf(printer, class, whichJobs, myJobs, firstJobId, limit, attributes)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// GetJobs is a helper method to define mock.On call
//   - printer string
//   - class string
//   - whichJobs string
//   - myJobs bool
//   - firstJobId int
//   - limit int
//   - attributes []string
func (_e *MockCUPSClientInterface_Expecter) GetJobs(printer interface{}, class interface{}, whichJobs interface{}, myJobs interface{}, firstJobId interface{}, limit interface{}, attributes interface{}) *MockCUPSClientInterface_GetJobs_Call {
	return &MockCUPSClientInterface_GetJobs_Call{Call: _e.mock.On("GetJobs", printer, class, whichJobs, myJobs, firstJobId, limit, attributes)}
}

func (_c *MockCUPSClientInterface_GetJobs_Call) Run(run func(printer string, class string, whichJobs string, myJobs bool, firstJobId int, limit int, attributes []string)) *MockCUPSClientInterface_GetJobs_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(string), args[1].(string), args[2].(string), args[3].(bool), args[4].(int), args[5].(int), args[6].([]string))
	})
	return _c
}

func (_c *MockCUPSClientInterface_GetJobs_Call) Return(_a0 map[int]ipp.Attributes, _a1 error) *MockCUPSClientInterface_GetJobs_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockCUPSClientInterface_GetJobs_Call) RunAndReturn(run func(string, string, string, bool, int, int, []string) (map[int]ipp.Attributes, error)) *MockCUPSClientInterface_GetJobs_Call {
	_c.Call.Return(run)
	return _c
}

// GetPrinters provides a mock function with given fields: attributes
func (_m *MockCUPSClientInterface) GetPrinters(attributes []string) (map[string]ipp.Attributes, error) {
	ret := _m.Called(attributes)

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

	var r0 map[string]ipp.Attributes
	var r1 error
	if rf, ok := ret.Get(0).(func([]string) (map[string]ipp.Attributes, error)); ok {
		return rf(attributes)
	}
	if rf, ok := ret.Get(0).(func([]string) map[string]ipp.Attributes); ok {
		r0 = rf(attributes)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(map[string]ipp.Attributes)
		}
	}

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

	return r0, r1
}

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

// GetPrinters is a helper method to define mock.On call
//   - attributes []string
func (_e *MockCUPSClientInterface_Expecter) GetPrinters(attributes interface{}) *MockCUPSClientInterface_GetPrinters_Call {
	return &MockCUPSClientInterface_GetPrinters_Call{Call: _e.mock.On("GetPrinters", attributes)}
}

func (_c *MockCUPSClientInterface_GetPrinters_Call) Run(run func(attributes []string)) *MockCUPSClientInterface_GetPrinters_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].([]string))
	})
	return _c
}

func (_c *MockCUPSClientInterface_GetPrinters_Call) Return(_a0 map[string]ipp.Attributes, _a1 error) *MockCUPSClientInterface_GetPrinters_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockCUPSClientInterface_GetPrinters_Call) RunAndReturn(run func([]string) (map[string]ipp.Attributes, error)) *MockCUPSClientInterface_GetPrinters_Call {
	_c.Call.Return(run)
	return _c
}

// PausePrinter provides a mock function with given fields: printer
func (_m *MockCUPSClientInterface) PausePrinter(printer string) error {
	ret := _m.Called(printer)

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

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

	return r0
}

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

// PausePrinter is a helper method to define mock.On call
//   - printer string
func (_e *MockCUPSClientInterface_Expecter) PausePrinter(printer interface{}) *MockCUPSClientInterface_PausePrinter_Call {
	return &MockCUPSClientInterface_PausePrinter_Call{Call: _e.mock.On("PausePrinter", printer)}
}

func (_c *MockCUPSClientInterface_PausePrinter_Call) Run(run func(printer string)) *MockCUPSClientInterface_PausePrinter_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(string))
	})
	return _c
}

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

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

// ResumePrinter provides a mock function with given fields: printer
func (_m *MockCUPSClientInterface) ResumePrinter(printer string) error {
	ret := _m.Called(printer)

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

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

	return r0
}

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

// ResumePrinter is a helper method to define mock.On call
//   - printer string
func (_e *MockCUPSClientInterface_Expecter) ResumePrinter(printer interface{}) *MockCUPSClientInterface_ResumePrinter_Call {
	return &MockCUPSClientInterface_ResumePrinter_Call{Call: _e.mock.On("ResumePrinter", printer)}
}

func (_c *MockCUPSClientInterface_ResumePrinter_Call) Run(run func(printer string)) *MockCUPSClientInterface_ResumePrinter_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(string))
	})
	return _c
}

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

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

// SendRequest provides a mock function with given fields: url, req, additionalResponseData
func (_m *MockCUPSClientInterface) SendRequest(url string, req *ipp.Request, additionalResponseData io.Writer) (*ipp.Response, error) {
	ret := _m.Called(url, req, additionalResponseData)

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

	var r0 *ipp.Response
	var r1 error
	if rf, ok := ret.Get(0).(func(string, *ipp.Request, io.Writer) (*ipp.Response, error)); ok {
		return rf(url, req, additionalResponseData)
	}
	if rf, ok := ret.Get(0).(func(string, *ipp.Request, io.Writer) *ipp.Response); ok {
		r0 = rf(url, req, additionalResponseData)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ipp.Response)
		}
	}

	if rf, ok := ret.Get(1).(func(string, *ipp.Request, io.Writer) error); ok {
		r1 = rf(url, req, additionalResponseData)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// SendRequest is a helper method to define mock.On call
//   - url string
//   - req *ipp.Request
//   - additionalResponseData io.Writer
func (_e *MockCUPSClientInterface_Expecter) SendRequest(url interface{}, req interface{}, additionalResponseData interface{}) *MockCUPSClientInterface_SendRequest_Call {
	return &MockCUPSClientInterface_SendRequest_Call{Call: _e.mock.On("SendRequest", url, req, additionalResponseData)}
}

func (_c *MockCUPSClientInterface_SendRequest_Call) Run(run func(url string, req *ipp.Request, additionalResponseData io.Writer)) *MockCUPSClientInterface_SendRequest_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(string), args[1].(*ipp.Request), args[2].(io.Writer))
	})
	return _c
}

func (_c *MockCUPSClientInterface_SendRequest_Call) Return(_a0 *ipp.Response, _a1 error) *MockCUPSClientInterface_SendRequest_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockCUPSClientInterface_SendRequest_Call) RunAndReturn(run func(string, *ipp.Request, io.Writer) (*ipp.Response, error)) *MockCUPSClientInterface_SendRequest_Call {
	_c.Call.Return(run)
	return _c
}

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

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

	return mock
}