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

package mocks

import (
	"context"
	"net/http"
	"os"

	"github.com/mendersoftware/mender-server/pkg/api/client"
	mock "github.com/stretchr/testify/mock"
)

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

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

	return mock
}

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

type MockDeploymentsDeviceAPIAPI_Expecter struct {
	mock *mock.Mock
}

func (_m *MockDeploymentsDeviceAPIAPI) EXPECT() *MockDeploymentsDeviceAPIAPI_Expecter {
	return &MockDeploymentsDeviceAPIAPI_Expecter{mock: &_m.Mock}
}

// CheckUpdate provides a mock function for the type MockDeploymentsDeviceAPIAPI
func (_mock *MockDeploymentsDeviceAPIAPI) CheckUpdate(ctx context.Context) client.ApiCheckUpdateRequest {
	ret := _mock.Called(ctx)

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

	var r0 client.ApiCheckUpdateRequest
	if returnFunc, ok := ret.Get(0).(func(context.Context) client.ApiCheckUpdateRequest); ok {
		r0 = returnFunc(ctx)
	} else {
		r0 = ret.Get(0).(client.ApiCheckUpdateRequest)
	}
	return r0
}

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

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

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

func (_c *MockDeploymentsDeviceAPIAPI_CheckUpdate_Call) Return(apiCheckUpdateRequest client.ApiCheckUpdateRequest) *MockDeploymentsDeviceAPIAPI_CheckUpdate_Call {
	_c.Call.Return(apiCheckUpdateRequest)
	return _c
}

func (_c *MockDeploymentsDeviceAPIAPI_CheckUpdate_Call) RunAndReturn(run func(ctx context.Context) client.ApiCheckUpdateRequest) *MockDeploymentsDeviceAPIAPI_CheckUpdate_Call {
	_c.Call.Return(run)
	return _c
}

// CheckUpdateExecute provides a mock function for the type MockDeploymentsDeviceAPIAPI
func (_mock *MockDeploymentsDeviceAPIAPI) CheckUpdateExecute(r client.ApiCheckUpdateRequest) (*client.DeploymentInstructions, *http.Response, error) {
	ret := _mock.Called(r)

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

	var r0 *client.DeploymentInstructions
	var r1 *http.Response
	var r2 error
	if returnFunc, ok := ret.Get(0).(func(client.ApiCheckUpdateRequest) (*client.DeploymentInstructions, *http.Response, error)); ok {
		return returnFunc(r)
	}
	if returnFunc, ok := ret.Get(0).(func(client.ApiCheckUpdateRequest) *client.DeploymentInstructions); ok {
		r0 = returnFunc(r)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*client.DeploymentInstructions)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(client.ApiCheckUpdateRequest) *http.Response); ok {
		r1 = returnFunc(r)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*http.Response)
		}
	}
	if returnFunc, ok := ret.Get(2).(func(client.ApiCheckUpdateRequest) error); ok {
		r2 = returnFunc(r)
	} else {
		r2 = ret.Error(2)
	}
	return r0, r1, r2
}

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

// CheckUpdateExecute is a helper method to define mock.On call
//   - r client.ApiCheckUpdateRequest
func (_e *MockDeploymentsDeviceAPIAPI_Expecter) CheckUpdateExecute(r interface{}) *MockDeploymentsDeviceAPIAPI_CheckUpdateExecute_Call {
	return &MockDeploymentsDeviceAPIAPI_CheckUpdateExecute_Call{Call: _e.mock.On("CheckUpdateExecute", r)}
}

func (_c *MockDeploymentsDeviceAPIAPI_CheckUpdateExecute_Call) Run(run func(r client.ApiCheckUpdateRequest)) *MockDeploymentsDeviceAPIAPI_CheckUpdateExecute_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 client.ApiCheckUpdateRequest
		if args[0] != nil {
			arg0 = args[0].(client.ApiCheckUpdateRequest)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *MockDeploymentsDeviceAPIAPI_CheckUpdateExecute_Call) Return(deploymentInstructions *client.DeploymentInstructions, response *http.Response, err error) *MockDeploymentsDeviceAPIAPI_CheckUpdateExecute_Call {
	_c.Call.Return(deploymentInstructions, response, err)
	return _c
}

func (_c *MockDeploymentsDeviceAPIAPI_CheckUpdateExecute_Call) RunAndReturn(run func(r client.ApiCheckUpdateRequest) (*client.DeploymentInstructions, *http.Response, error)) *MockDeploymentsDeviceAPIAPI_CheckUpdateExecute_Call {
	_c.Call.Return(run)
	return _c
}

// FetchConfiguration provides a mock function for the type MockDeploymentsDeviceAPIAPI
func (_mock *MockDeploymentsDeviceAPIAPI) FetchConfiguration(ctx context.Context, deploymentId string, deviceType string, deviceId string) client.ApiFetchConfigurationRequest {
	ret := _mock.Called(ctx, deploymentId, deviceType, deviceId)

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

	var r0 client.ApiFetchConfigurationRequest
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, string) client.ApiFetchConfigurationRequest); ok {
		r0 = returnFunc(ctx, deploymentId, deviceType, deviceId)
	} else {
		r0 = ret.Get(0).(client.ApiFetchConfigurationRequest)
	}
	return r0
}

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

// FetchConfiguration is a helper method to define mock.On call
//   - ctx context.Context
//   - deploymentId string
//   - deviceType string
//   - deviceId string
func (_e *MockDeploymentsDeviceAPIAPI_Expecter) FetchConfiguration(ctx interface{}, deploymentId interface{}, deviceType interface{}, deviceId interface{}) *MockDeploymentsDeviceAPIAPI_FetchConfiguration_Call {
	return &MockDeploymentsDeviceAPIAPI_FetchConfiguration_Call{Call: _e.mock.On("FetchConfiguration", ctx, deploymentId, deviceType, deviceId)}
}

func (_c *MockDeploymentsDeviceAPIAPI_FetchConfiguration_Call) Run(run func(ctx context.Context, deploymentId string, deviceType string, deviceId string)) *MockDeploymentsDeviceAPIAPI_FetchConfiguration_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 string
		if args[3] != nil {
			arg3 = args[3].(string)
		}
		run(
			arg0,
			arg1,
			arg2,
			arg3,
		)
	})
	return _c
}

func (_c *MockDeploymentsDeviceAPIAPI_FetchConfiguration_Call) Return(apiFetchConfigurationRequest client.ApiFetchConfigurationRequest) *MockDeploymentsDeviceAPIAPI_FetchConfiguration_Call {
	_c.Call.Return(apiFetchConfigurationRequest)
	return _c
}

func (_c *MockDeploymentsDeviceAPIAPI_FetchConfiguration_Call) RunAndReturn(run func(ctx context.Context, deploymentId string, deviceType string, deviceId string) client.ApiFetchConfigurationRequest) *MockDeploymentsDeviceAPIAPI_FetchConfiguration_Call {
	_c.Call.Return(run)
	return _c
}

// FetchConfigurationExecute provides a mock function for the type MockDeploymentsDeviceAPIAPI
func (_mock *MockDeploymentsDeviceAPIAPI) FetchConfigurationExecute(r client.ApiFetchConfigurationRequest) (*os.File, *http.Response, error) {
	ret := _mock.Called(r)

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

	var r0 *os.File
	var r1 *http.Response
	var r2 error
	if returnFunc, ok := ret.Get(0).(func(client.ApiFetchConfigurationRequest) (*os.File, *http.Response, error)); ok {
		return returnFunc(r)
	}
	if returnFunc, ok := ret.Get(0).(func(client.ApiFetchConfigurationRequest) *os.File); ok {
		r0 = returnFunc(r)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*os.File)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(client.ApiFetchConfigurationRequest) *http.Response); ok {
		r1 = returnFunc(r)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*http.Response)
		}
	}
	if returnFunc, ok := ret.Get(2).(func(client.ApiFetchConfigurationRequest) error); ok {
		r2 = returnFunc(r)
	} else {
		r2 = ret.Error(2)
	}
	return r0, r1, r2
}

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

// FetchConfigurationExecute is a helper method to define mock.On call
//   - r client.ApiFetchConfigurationRequest
func (_e *MockDeploymentsDeviceAPIAPI_Expecter) FetchConfigurationExecute(r interface{}) *MockDeploymentsDeviceAPIAPI_FetchConfigurationExecute_Call {
	return &MockDeploymentsDeviceAPIAPI_FetchConfigurationExecute_Call{Call: _e.mock.On("FetchConfigurationExecute", r)}
}

func (_c *MockDeploymentsDeviceAPIAPI_FetchConfigurationExecute_Call) Run(run func(r client.ApiFetchConfigurationRequest)) *MockDeploymentsDeviceAPIAPI_FetchConfigurationExecute_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 client.ApiFetchConfigurationRequest
		if args[0] != nil {
			arg0 = args[0].(client.ApiFetchConfigurationRequest)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *MockDeploymentsDeviceAPIAPI_FetchConfigurationExecute_Call) Return(file *os.File, response *http.Response, err error) *MockDeploymentsDeviceAPIAPI_FetchConfigurationExecute_Call {
	_c.Call.Return(file, response, err)
	return _c
}

func (_c *MockDeploymentsDeviceAPIAPI_FetchConfigurationExecute_Call) RunAndReturn(run func(r client.ApiFetchConfigurationRequest) (*os.File, *http.Response, error)) *MockDeploymentsDeviceAPIAPI_FetchConfigurationExecute_Call {
	_c.Call.Return(run)
	return _c
}

// ReportDeploymentLog provides a mock function for the type MockDeploymentsDeviceAPIAPI
func (_mock *MockDeploymentsDeviceAPIAPI) ReportDeploymentLog(ctx context.Context, id string) client.ApiReportDeploymentLogRequest {
	ret := _mock.Called(ctx, id)

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

	var r0 client.ApiReportDeploymentLogRequest
	if returnFunc, ok := ret.Get(0).(func(context.Context, string) client.ApiReportDeploymentLogRequest); ok {
		r0 = returnFunc(ctx, id)
	} else {
		r0 = ret.Get(0).(client.ApiReportDeploymentLogRequest)
	}
	return r0
}

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

// ReportDeploymentLog is a helper method to define mock.On call
//   - ctx context.Context
//   - id string
func (_e *MockDeploymentsDeviceAPIAPI_Expecter) ReportDeploymentLog(ctx interface{}, id interface{}) *MockDeploymentsDeviceAPIAPI_ReportDeploymentLog_Call {
	return &MockDeploymentsDeviceAPIAPI_ReportDeploymentLog_Call{Call: _e.mock.On("ReportDeploymentLog", ctx, id)}
}

func (_c *MockDeploymentsDeviceAPIAPI_ReportDeploymentLog_Call) Run(run func(ctx context.Context, id string)) *MockDeploymentsDeviceAPIAPI_ReportDeploymentLog_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 *MockDeploymentsDeviceAPIAPI_ReportDeploymentLog_Call) Return(apiReportDeploymentLogRequest client.ApiReportDeploymentLogRequest) *MockDeploymentsDeviceAPIAPI_ReportDeploymentLog_Call {
	_c.Call.Return(apiReportDeploymentLogRequest)
	return _c
}

func (_c *MockDeploymentsDeviceAPIAPI_ReportDeploymentLog_Call) RunAndReturn(run func(ctx context.Context, id string) client.ApiReportDeploymentLogRequest) *MockDeploymentsDeviceAPIAPI_ReportDeploymentLog_Call {
	_c.Call.Return(run)
	return _c
}

// ReportDeploymentLogExecute provides a mock function for the type MockDeploymentsDeviceAPIAPI
func (_mock *MockDeploymentsDeviceAPIAPI) ReportDeploymentLogExecute(r client.ApiReportDeploymentLogRequest) (*http.Response, error) {
	ret := _mock.Called(r)

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

	var r0 *http.Response
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(client.ApiReportDeploymentLogRequest) (*http.Response, error)); ok {
		return returnFunc(r)
	}
	if returnFunc, ok := ret.Get(0).(func(client.ApiReportDeploymentLogRequest) *http.Response); ok {
		r0 = returnFunc(r)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*http.Response)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(client.ApiReportDeploymentLogRequest) error); ok {
		r1 = returnFunc(r)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// ReportDeploymentLogExecute is a helper method to define mock.On call
//   - r client.ApiReportDeploymentLogRequest
func (_e *MockDeploymentsDeviceAPIAPI_Expecter) ReportDeploymentLogExecute(r interface{}) *MockDeploymentsDeviceAPIAPI_ReportDeploymentLogExecute_Call {
	return &MockDeploymentsDeviceAPIAPI_ReportDeploymentLogExecute_Call{Call: _e.mock.On("ReportDeploymentLogExecute", r)}
}

func (_c *MockDeploymentsDeviceAPIAPI_ReportDeploymentLogExecute_Call) Run(run func(r client.ApiReportDeploymentLogRequest)) *MockDeploymentsDeviceAPIAPI_ReportDeploymentLogExecute_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 client.ApiReportDeploymentLogRequest
		if args[0] != nil {
			arg0 = args[0].(client.ApiReportDeploymentLogRequest)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *MockDeploymentsDeviceAPIAPI_ReportDeploymentLogExecute_Call) Return(response *http.Response, err error) *MockDeploymentsDeviceAPIAPI_ReportDeploymentLogExecute_Call {
	_c.Call.Return(response, err)
	return _c
}

func (_c *MockDeploymentsDeviceAPIAPI_ReportDeploymentLogExecute_Call) RunAndReturn(run func(r client.ApiReportDeploymentLogRequest) (*http.Response, error)) *MockDeploymentsDeviceAPIAPI_ReportDeploymentLogExecute_Call {
	_c.Call.Return(run)
	return _c
}

// UpdateDeploymentStatus provides a mock function for the type MockDeploymentsDeviceAPIAPI
func (_mock *MockDeploymentsDeviceAPIAPI) UpdateDeploymentStatus(ctx context.Context, id string) client.ApiUpdateDeploymentStatusRequest {
	ret := _mock.Called(ctx, id)

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

	var r0 client.ApiUpdateDeploymentStatusRequest
	if returnFunc, ok := ret.Get(0).(func(context.Context, string) client.ApiUpdateDeploymentStatusRequest); ok {
		r0 = returnFunc(ctx, id)
	} else {
		r0 = ret.Get(0).(client.ApiUpdateDeploymentStatusRequest)
	}
	return r0
}

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

// UpdateDeploymentStatus is a helper method to define mock.On call
//   - ctx context.Context
//   - id string
func (_e *MockDeploymentsDeviceAPIAPI_Expecter) UpdateDeploymentStatus(ctx interface{}, id interface{}) *MockDeploymentsDeviceAPIAPI_UpdateDeploymentStatus_Call {
	return &MockDeploymentsDeviceAPIAPI_UpdateDeploymentStatus_Call{Call: _e.mock.On("UpdateDeploymentStatus", ctx, id)}
}

func (_c *MockDeploymentsDeviceAPIAPI_UpdateDeploymentStatus_Call) Run(run func(ctx context.Context, id string)) *MockDeploymentsDeviceAPIAPI_UpdateDeploymentStatus_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 *MockDeploymentsDeviceAPIAPI_UpdateDeploymentStatus_Call) Return(apiUpdateDeploymentStatusRequest client.ApiUpdateDeploymentStatusRequest) *MockDeploymentsDeviceAPIAPI_UpdateDeploymentStatus_Call {
	_c.Call.Return(apiUpdateDeploymentStatusRequest)
	return _c
}

func (_c *MockDeploymentsDeviceAPIAPI_UpdateDeploymentStatus_Call) RunAndReturn(run func(ctx context.Context, id string) client.ApiUpdateDeploymentStatusRequest) *MockDeploymentsDeviceAPIAPI_UpdateDeploymentStatus_Call {
	_c.Call.Return(run)
	return _c
}

// UpdateDeploymentStatusExecute provides a mock function for the type MockDeploymentsDeviceAPIAPI
func (_mock *MockDeploymentsDeviceAPIAPI) UpdateDeploymentStatusExecute(r client.ApiUpdateDeploymentStatusRequest) (*http.Response, error) {
	ret := _mock.Called(r)

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

	var r0 *http.Response
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(client.ApiUpdateDeploymentStatusRequest) (*http.Response, error)); ok {
		return returnFunc(r)
	}
	if returnFunc, ok := ret.Get(0).(func(client.ApiUpdateDeploymentStatusRequest) *http.Response); ok {
		r0 = returnFunc(r)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*http.Response)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(client.ApiUpdateDeploymentStatusRequest) error); ok {
		r1 = returnFunc(r)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// UpdateDeploymentStatusExecute is a helper method to define mock.On call
//   - r client.ApiUpdateDeploymentStatusRequest
func (_e *MockDeploymentsDeviceAPIAPI_Expecter) UpdateDeploymentStatusExecute(r interface{}) *MockDeploymentsDeviceAPIAPI_UpdateDeploymentStatusExecute_Call {
	return &MockDeploymentsDeviceAPIAPI_UpdateDeploymentStatusExecute_Call{Call: _e.mock.On("UpdateDeploymentStatusExecute", r)}
}

func (_c *MockDeploymentsDeviceAPIAPI_UpdateDeploymentStatusExecute_Call) Run(run func(r client.ApiUpdateDeploymentStatusRequest)) *MockDeploymentsDeviceAPIAPI_UpdateDeploymentStatusExecute_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 client.ApiUpdateDeploymentStatusRequest
		if args[0] != nil {
			arg0 = args[0].(client.ApiUpdateDeploymentStatusRequest)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *MockDeploymentsDeviceAPIAPI_UpdateDeploymentStatusExecute_Call) Return(response *http.Response, err error) *MockDeploymentsDeviceAPIAPI_UpdateDeploymentStatusExecute_Call {
	_c.Call.Return(response, err)
	return _c
}

func (_c *MockDeploymentsDeviceAPIAPI_UpdateDeploymentStatusExecute_Call) RunAndReturn(run func(r client.ApiUpdateDeploymentStatusRequest) (*http.Response, error)) *MockDeploymentsDeviceAPIAPI_UpdateDeploymentStatusExecute_Call {
	_c.Call.Return(run)
	return _c
}

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

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

	return mock
}

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

type MockDeploymentsInternalAPIInternalAPIAPI_Expecter struct {
	mock *mock.Mock
}

func (_m *MockDeploymentsInternalAPIInternalAPIAPI) EXPECT() *MockDeploymentsInternalAPIInternalAPIAPI_Expecter {
	return &MockDeploymentsInternalAPIInternalAPIAPI_Expecter{mock: &_m.Mock}
}

// DeploymentsInternalCheckHealth provides a mock function for the type MockDeploymentsInternalAPIInternalAPIAPI
func (_mock *MockDeploymentsInternalAPIInternalAPIAPI) DeploymentsInternalCheckHealth(ctx context.Context) client.ApiDeploymentsInternalCheckHealthRequest {
	ret := _mock.Called(ctx)

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

	var r0 client.ApiDeploymentsInternalCheckHealthRequest
	if returnFunc, ok := ret.Get(0).(func(context.Context) client.ApiDeploymentsInternalCheckHealthRequest); ok {
		r0 = returnFunc(ctx)
	} else {
		r0 = ret.Get(0).(client.ApiDeploymentsInternalCheckHealthRequest)
	}
	return r0
}

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

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

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

func (_c *MockDeploymentsInternalAPIInternalAPIAPI_DeploymentsInternalCheckHealth_Call) Return(apiDeploymentsInternalCheckHealthRequest client.ApiDeploymentsInternalCheckHealthRequest) *MockDeploymentsInternalAPIInternalAPIAPI_DeploymentsInternalCheckHealth_Call {
	_c.Call.Return(apiDeploymentsInternalCheckHealthRequest)
	return _c
}

func (_c *MockDeploymentsInternalAPIInternalAPIAPI_DeploymentsInternalCheckHealth_Call) RunAndReturn(run func(ctx context.Context) client.ApiDeploymentsInternalCheckHealthRequest) *MockDeploymentsInternalAPIInternalAPIAPI_DeploymentsInternalCheckHealth_Call {
	_c.Call.Return(run)
	return _c
}

// DeploymentsInternalCheckHealthExecute provides a mock function for the type MockDeploymentsInternalAPIInternalAPIAPI
func (_mock *MockDeploymentsInternalAPIInternalAPIAPI) DeploymentsInternalCheckHealthExecute(r client.ApiDeploymentsInternalCheckHealthRequest) (*http.Response, error) {
	ret := _mock.Called(r)

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

	var r0 *http.Response
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(client.ApiDeploymentsInternalCheckHealthRequest) (*http.Response, error)); ok {
		return returnFunc(r)
	}
	if returnFunc, ok := ret.Get(0).(func(client.ApiDeploymentsInternalCheckHealthRequest) *http.Response); ok {
		r0 = returnFunc(r)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*http.Response)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(client.ApiDeploymentsInternalCheckHealthRequest) error); ok {
		r1 = returnFunc(r)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// DeploymentsInternalCheckHealthExecute is a helper method to define mock.On call
//   - r client.ApiDeploymentsInternalCheckHealthRequest
func (_e *MockDeploymentsInternalAPIInternalAPIAPI_Expecter) DeploymentsInternalCheckHealthExecute(r interface{}) *MockDeploymentsInternalAPIInternalAPIAPI_DeploymentsInternalCheckHealthExecute_Call {
	return &MockDeploymentsInternalAPIInternalAPIAPI_DeploymentsInternalCheckHealthExecute_Call{Call: _e.mock.On("DeploymentsInternalCheckHealthExecute", r)}
}

func (_c *MockDeploymentsInternalAPIInternalAPIAPI_DeploymentsInternalCheckHealthExecute_Call) Run(run func(r client.ApiDeploymentsInternalCheckHealthRequest)) *MockDeploymentsInternalAPIInternalAPIAPI_DeploymentsInternalCheckHealthExecute_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 client.ApiDeploymentsInternalCheckHealthRequest
		if args[0] != nil {
			arg0 = args[0].(client.ApiDeploymentsInternalCheckHealthRequest)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *MockDeploymentsInternalAPIInternalAPIAPI_DeploymentsInternalCheckHealthExecute_Call) Return(response *http.Response, err error) *MockDeploymentsInternalAPIInternalAPIAPI_DeploymentsInternalCheckHealthExecute_Call {
	_c.Call.Return(response, err)
	return _c
}

func (_c *MockDeploymentsInternalAPIInternalAPIAPI_DeploymentsInternalCheckHealthExecute_Call) RunAndReturn(run func(r client.ApiDeploymentsInternalCheckHealthRequest) (*http.Response, error)) *MockDeploymentsInternalAPIInternalAPIAPI_DeploymentsInternalCheckHealthExecute_Call {
	_c.Call.Return(run)
	return _c
}

// DeploymentsInternalCheckLiveliness provides a mock function for the type MockDeploymentsInternalAPIInternalAPIAPI
func (_mock *MockDeploymentsInternalAPIInternalAPIAPI) DeploymentsInternalCheckLiveliness(ctx context.Context) client.ApiDeploymentsInternalCheckLivelinessRequest {
	ret := _mock.Called(ctx)

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

	var r0 client.ApiDeploymentsInternalCheckLivelinessRequest
	if returnFunc, ok := ret.Get(0).(func(context.Context) client.ApiDeploymentsInternalCheckLivelinessRequest); ok {
		r0 = returnFunc(ctx)
	} else {
		r0 = ret.Get(0).(client.ApiDeploymentsInternalCheckLivelinessRequest)
	}
	return r0
}

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

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

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

func (_c *MockDeploymentsInternalAPIInternalAPIAPI_DeploymentsInternalCheckLiveliness_Call) Return(apiDeploymentsInternalCheckLivelinessRequest client.ApiDeploymentsInternalCheckLivelinessRequest) *MockDeploymentsInternalAPIInternalAPIAPI_DeploymentsInternalCheckLiveliness_Call {
	_c.Call.Return(apiDeploymentsInternalCheckLivelinessRequest)
	return _c
}

func (_c *MockDeploymentsInternalAPIInternalAPIAPI_DeploymentsInternalCheckLiveliness_Call) RunAndReturn(run func(ctx context.Context) client.ApiDeploymentsInternalCheckLivelinessRequest) *MockDeploymentsInternalAPIInternalAPIAPI_DeploymentsInternalCheckLiveliness_Call {
	_c.Call.Return(run)
	return _c
}

// DeploymentsInternalCheckLivelinessExecute provides a mock function for the type MockDeploymentsInternalAPIInternalAPIAPI
func (_mock *MockDeploymentsInternalAPIInternalAPIAPI) DeploymentsInternalCheckLivelinessExecute(r client.ApiDeploymentsInternalCheckLivelinessRequest) (*http.Response, error) {
	ret := _mock.Called(r)

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

	var r0 *http.Response
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(client.ApiDeploymentsInternalCheckLivelinessRequest) (*http.Response, error)); ok {
		return returnFunc(r)
	}
	if returnFunc, ok := ret.Get(0).(func(client.ApiDeploymentsInternalCheckLivelinessRequest) *http.Response); ok {
		r0 = returnFunc(r)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*http.Response)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(client.ApiDeploymentsInternalCheckLivelinessRequest) error); ok {
		r1 = returnFunc(r)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// DeploymentsInternalCheckLivelinessExecute is a helper method to define mock.On call
//   - r client.ApiDeploymentsInternalCheckLivelinessRequest
func (_e *MockDeploymentsInternalAPIInternalAPIAPI_Expecter) DeploymentsInternalCheckLivelinessExecute(r interface{}) *MockDeploymentsInternalAPIInternalAPIAPI_DeploymentsInternalCheckLivelinessExecute_Call {
	return &MockDeploymentsInternalAPIInternalAPIAPI_DeploymentsInternalCheckLivelinessExecute_Call{Call: _e.mock.On("DeploymentsInternalCheckLivelinessExecute", r)}
}

func (_c *MockDeploymentsInternalAPIInternalAPIAPI_DeploymentsInternalCheckLivelinessExecute_Call) Run(run func(r client.ApiDeploymentsInternalCheckLivelinessRequest)) *MockDeploymentsInternalAPIInternalAPIAPI_DeploymentsInternalCheckLivelinessExecute_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 client.ApiDeploymentsInternalCheckLivelinessRequest
		if args[0] != nil {
			arg0 = args[0].(client.ApiDeploymentsInternalCheckLivelinessRequest)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *MockDeploymentsInternalAPIInternalAPIAPI_DeploymentsInternalCheckLivelinessExecute_Call) Return(response *http.Response, err error) *MockDeploymentsInternalAPIInternalAPIAPI_DeploymentsInternalCheckLivelinessExecute_Call {
	_c.Call.Return(response, err)
	return _c
}

func (_c *MockDeploymentsInternalAPIInternalAPIAPI_DeploymentsInternalCheckLivelinessExecute_Call) RunAndReturn(run func(r client.ApiDeploymentsInternalCheckLivelinessRequest) (*http.Response, error)) *MockDeploymentsInternalAPIInternalAPIAPI_DeploymentsInternalCheckLivelinessExecute_Call {
	_c.Call.Return(run)
	return _c
}

// DeploymentsInternalCreateDeployment provides a mock function for the type MockDeploymentsInternalAPIInternalAPIAPI
func (_mock *MockDeploymentsInternalAPIInternalAPIAPI) DeploymentsInternalCreateDeployment(ctx context.Context, tenantId string, deviceId string, deploymentId string) client.ApiDeploymentsInternalCreateDeploymentRequest {
	ret := _mock.Called(ctx, tenantId, deviceId, deploymentId)

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

	var r0 client.ApiDeploymentsInternalCreateDeploymentRequest
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, string) client.ApiDeploymentsInternalCreateDeploymentRequest); ok {
		r0 = returnFunc(ctx, tenantId, deviceId, deploymentId)
	} else {
		r0 = ret.Get(0).(client.ApiDeploymentsInternalCreateDeploymentRequest)
	}
	return r0
}

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

// DeploymentsInternalCreateDeployment is a helper method to define mock.On call
//   - ctx context.Context
//   - tenantId string
//   - deviceId string
//   - deploymentId string
func (_e *MockDeploymentsInternalAPIInternalAPIAPI_Expecter) DeploymentsInternalCreateDeployment(ctx interface{}, tenantId interface{}, deviceId interface{}, deploymentId interface{}) *MockDeploymentsInternalAPIInternalAPIAPI_DeploymentsInternalCreateDeployment_Call {
	return &MockDeploymentsInternalAPIInternalAPIAPI_DeploymentsInternalCreateDeployment_Call{Call: _e.mock.On("DeploymentsInternalCreateDeployment", ctx, tenantId, deviceId, deploymentId)}
}

func (_c *MockDeploymentsInternalAPIInternalAPIAPI_DeploymentsInternalCreateDeployment_Call) Run(run func(ctx context.Context, tenantId string, deviceId string, deploymentId string)) *MockDeploymentsInternalAPIInternalAPIAPI_DeploymentsInternalCreateDeployment_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 string
		if args[3] != nil {
			arg3 = args[3].(string)
		}
		run(
			arg0,
			arg1,
			arg2,
			arg3,
		)
	})
	return _c
}

func (_c *MockDeploymentsInternalAPIInternalAPIAPI_DeploymentsInternalCreateDeployment_Call) Return(apiDeploymentsInternalCreateDeploymentRequest client.ApiDeploymentsInternalCreateDeploymentRequest) *MockDeploymentsInternalAPIInternalAPIAPI_DeploymentsInternalCreateDeployment_Call {
	_c.Call.Return(apiDeploymentsInternalCreateDeploymentRequest)
	return _c
}

func (_c *MockDeploymentsInternalAPIInternalAPIAPI_DeploymentsInternalCreateDeployment_Call) RunAndReturn(run func(ctx context.Context, tenantId string, deviceId string, deploymentId string) client.ApiDeploymentsInternalCreateDeploymentRequest) *MockDeploymentsInternalAPIInternalAPIAPI_DeploymentsInternalCreateDeployment_Call {
	_c.Call.Return(run)
	return _c
}

// DeploymentsInternalCreateDeploymentExecute provides a mock function for the type MockDeploymentsInternalAPIInternalAPIAPI
func (_mock *MockDeploymentsInternalAPIInternalAPIAPI) DeploymentsInternalCreateDeploymentExecute(r client.ApiDeploymentsInternalCreateDeploymentRequest) (*http.Response, error) {
	ret := _mock.Called(r)

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

	var r0 *http.Response
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(client.ApiDeploymentsInternalCreateDeploymentRequest) (*http.Response, error)); ok {
		return returnFunc(r)
	}
	if returnFunc, ok := ret.Get(0).(func(client.ApiDeploymentsInternalCreateDeploymentRequest) *http.Response); ok {
		r0 = returnFunc(r)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*http.Response)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(client.ApiDeploymentsInternalCreateDeploymentRequest) error); ok {
		r1 = returnFunc(r)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// DeploymentsInternalCreateDeploymentExecute is a helper method to define mock.On call
//   - r client.ApiDeploymentsInternalCreateDeploymentRequest
func (_e *MockDeploymentsInternalAPIInternalAPIAPI_Expecter) DeploymentsInternalCreateDeploymentExecute(r interface{}) *MockDeploymentsInternalAPIInternalAPIAPI_DeploymentsInternalCreateDeploymentExecute_Call {
	return &MockDeploymentsInternalAPIInternalAPIAPI_DeploymentsInternalCreateDeploymentExecute_Call{Call: _e.mock.On("DeploymentsInternalCreateDeploymentExecute", r)}
}

func (_c *MockDeploymentsInternalAPIInternalAPIAPI_DeploymentsInternalCreateDeploymentExecute_Call) Run(run func(r client.ApiDeploymentsInternalCreateDeploymentRequest)) *MockDeploymentsInternalAPIInternalAPIAPI_DeploymentsInternalCreateDeploymentExecute_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 client.ApiDeploymentsInternalCreateDeploymentRequest
		if args[0] != nil {
			arg0 = args[0].(client.ApiDeploymentsInternalCreateDeploymentRequest)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *MockDeploymentsInternalAPIInternalAPIAPI_DeploymentsInternalCreateDeploymentExecute_Call) Return(response *http.Response, err error) *MockDeploymentsInternalAPIInternalAPIAPI_DeploymentsInternalCreateDeploymentExecute_Call {
	_c.Call.Return(response, err)
	return _c
}

func (_c *MockDeploymentsInternalAPIInternalAPIAPI_DeploymentsInternalCreateDeploymentExecute_Call) RunAndReturn(run func(r client.ApiDeploymentsInternalCreateDeploymentRequest) (*http.Response, error)) *MockDeploymentsInternalAPIInternalAPIAPI_DeploymentsInternalCreateDeploymentExecute_Call {
	_c.Call.Return(run)
	return _c
}

// DeploymentsInternalCreateTenant provides a mock function for the type MockDeploymentsInternalAPIInternalAPIAPI
func (_mock *MockDeploymentsInternalAPIInternalAPIAPI) DeploymentsInternalCreateTenant(ctx context.Context) client.ApiDeploymentsInternalCreateTenantRequest {
	ret := _mock.Called(ctx)

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

	var r0 client.ApiDeploymentsInternalCreateTenantRequest
	if returnFunc, ok := ret.Get(0).(func(context.Context) client.ApiDeploymentsInternalCreateTenantRequest); ok {
		r0 = returnFunc(ctx)
	} else {
		r0 = ret.Get(0).(client.ApiDeploymentsInternalCreateTenantRequest)
	}
	return r0
}

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

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

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

func (_c *MockDeploymentsInternalAPIInternalAPIAPI_DeploymentsInternalCreateTenant_Call) Return(apiDeploymentsInternalCreateTenantRequest client.ApiDeploymentsInternalCreateTenantRequest) *MockDeploymentsInternalAPIInternalAPIAPI_DeploymentsInternalCreateTenant_Call {
	_c.Call.Return(apiDeploymentsInternalCreateTenantRequest)
	return _c
}

func (_c *MockDeploymentsInternalAPIInternalAPIAPI_DeploymentsInternalCreateTenant_Call) RunAndReturn(run func(ctx context.Context) client.ApiDeploymentsInternalCreateTenantRequest) *MockDeploymentsInternalAPIInternalAPIAPI_DeploymentsInternalCreateTenant_Call {
	_c.Call.Return(run)
	return _c
}

// DeploymentsInternalCreateTenantExecute provides a mock function for the type MockDeploymentsInternalAPIInternalAPIAPI
func (_mock *MockDeploymentsInternalAPIInternalAPIAPI) DeploymentsInternalCreateTenantExecute(r client.ApiDeploymentsInternalCreateTenantRequest) (*http.Response, error) {
	ret := _mock.Called(r)

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

	var r0 *http.Response
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(client.ApiDeploymentsInternalCreateTenantRequest) (*http.Response, error)); ok {
		return returnFunc(r)
	}
	if returnFunc, ok := ret.Get(0).(func(client.ApiDeploymentsInternalCreateTenantRequest) *http.Response); ok {
		r0 = returnFunc(r)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*http.Response)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(client.ApiDeploymentsInternalCreateTenantRequest) error); ok {
		r1 = returnFunc(r)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// DeploymentsInternalCreateTenantExecute is a helper method to define mock.On call
//   - r client.ApiDeploymentsInternalCreateTenantRequest
func (_e *MockDeploymentsInternalAPIInternalAPIAPI_Expecter) DeploymentsInternalCreateTenantExecute(r interface{}) *MockDeploymentsInternalAPIInternalAPIAPI_DeploymentsInternalCreateTenantExecute_Call {
	return &MockDeploymentsInternalAPIInternalAPIAPI_DeploymentsInternalCreateTenantExecute_Call{Call: _e.mock.On("DeploymentsInternalCreateTenantExecute", r)}
}

func (_c *MockDeploymentsInternalAPIInternalAPIAPI_DeploymentsInternalCreateTenantExecute_Call) Run(run func(r client.ApiDeploymentsInternalCreateTenantRequest)) *MockDeploymentsInternalAPIInternalAPIAPI_DeploymentsInternalCreateTenantExecute_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 client.ApiDeploymentsInternalCreateTenantRequest
		if args[0] != nil {
			arg0 = args[0].(client.ApiDeploymentsInternalCreateTenantRequest)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *MockDeploymentsInternalAPIInternalAPIAPI_DeploymentsInternalCreateTenantExecute_Call) Return(response *http.Response, err error) *MockDeploymentsInternalAPIInternalAPIAPI_DeploymentsInternalCreateTenantExecute_Call {
	_c.Call.Return(response, err)
	return _c
}

func (_c *MockDeploymentsInternalAPIInternalAPIAPI_DeploymentsInternalCreateTenantExecute_Call) RunAndReturn(run func(r client.ApiDeploymentsInternalCreateTenantRequest) (*http.Response, error)) *MockDeploymentsInternalAPIInternalAPIAPI_DeploymentsInternalCreateTenantExecute_Call {
	_c.Call.Return(run)
	return _c
}

// DeploymentsInternalGetStorageUsage provides a mock function for the type MockDeploymentsInternalAPIInternalAPIAPI
func (_mock *MockDeploymentsInternalAPIInternalAPIAPI) DeploymentsInternalGetStorageUsage(ctx context.Context, id string) client.ApiDeploymentsInternalGetStorageUsageRequest {
	ret := _mock.Called(ctx, id)

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

	var r0 client.ApiDeploymentsInternalGetStorageUsageRequest
	if returnFunc, ok := ret.Get(0).(func(context.Context, string) client.ApiDeploymentsInternalGetStorageUsageRequest); ok {
		r0 = returnFunc(ctx, id)
	} else {
		r0 = ret.Get(0).(client.ApiDeploymentsInternalGetStorageUsageRequest)
	}
	return r0
}

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

// DeploymentsInternalGetStorageUsage is a helper method to define mock.On call
//   - ctx context.Context
//   - id string
func (_e *MockDeploymentsInternalAPIInternalAPIAPI_Expecter) DeploymentsInternalGetStorageUsage(ctx interface{}, id interface{}) *MockDeploymentsInternalAPIInternalAPIAPI_DeploymentsInternalGetStorageUsage_Call {
	return &MockDeploymentsInternalAPIInternalAPIAPI_DeploymentsInternalGetStorageUsage_Call{Call: _e.mock.On("DeploymentsInternalGetStorageUsage", ctx, id)}
}

func (_c *MockDeploymentsInternalAPIInternalAPIAPI_DeploymentsInternalGetStorageUsage_Call) Run(run func(ctx context.Context, id string)) *MockDeploymentsInternalAPIInternalAPIAPI_DeploymentsInternalGetStorageUsage_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 *MockDeploymentsInternalAPIInternalAPIAPI_DeploymentsInternalGetStorageUsage_Call) Return(apiDeploymentsInternalGetStorageUsageRequest client.ApiDeploymentsInternalGetStorageUsageRequest) *MockDeploymentsInternalAPIInternalAPIAPI_DeploymentsInternalGetStorageUsage_Call {
	_c.Call.Return(apiDeploymentsInternalGetStorageUsageRequest)
	return _c
}

func (_c *MockDeploymentsInternalAPIInternalAPIAPI_DeploymentsInternalGetStorageUsage_Call) RunAndReturn(run func(ctx context.Context, id string) client.ApiDeploymentsInternalGetStorageUsageRequest) *MockDeploymentsInternalAPIInternalAPIAPI_DeploymentsInternalGetStorageUsage_Call {
	_c.Call.Return(run)
	return _c
}

// DeploymentsInternalGetStorageUsageExecute provides a mock function for the type MockDeploymentsInternalAPIInternalAPIAPI
func (_mock *MockDeploymentsInternalAPIInternalAPIAPI) DeploymentsInternalGetStorageUsageExecute(r client.ApiDeploymentsInternalGetStorageUsageRequest) (*client.StorageUsage, *http.Response, error) {
	ret := _mock.Called(r)

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

	var r0 *client.StorageUsage
	var r1 *http.Response
	var r2 error
	if returnFunc, ok := ret.Get(0).(func(client.ApiDeploymentsInternalGetStorageUsageRequest) (*client.StorageUsage, *http.Response, error)); ok {
		return returnFunc(r)
	}
	if returnFunc, ok := ret.Get(0).(func(client.ApiDeploymentsInternalGetStorageUsageRequest) *client.StorageUsage); ok {
		r0 = returnFunc(r)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*client.StorageUsage)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(client.ApiDeploymentsInternalGetStorageUsageRequest) *http.Response); ok {
		r1 = returnFunc(r)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*http.Response)
		}
	}
	if returnFunc, ok := ret.Get(2).(func(client.ApiDeploymentsInternalGetStorageUsageRequest) error); ok {
		r2 = returnFunc(r)
	} else {
		r2 = ret.Error(2)
	}
	return r0, r1, r2
}

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

// DeploymentsInternalGetStorageUsageExecute is a helper method to define mock.On call
//   - r client.ApiDeploymentsInternalGetStorageUsageRequest
func (_e *MockDeploymentsInternalAPIInternalAPIAPI_Expecter) DeploymentsInternalGetStorageUsageExecute(r interface{}) *MockDeploymentsInternalAPIInternalAPIAPI_DeploymentsInternalGetStorageUsageExecute_Call {
	return &MockDeploymentsInternalAPIInternalAPIAPI_DeploymentsInternalGetStorageUsageExecute_Call{Call: _e.mock.On("DeploymentsInternalGetStorageUsageExecute", r)}
}

func (_c *MockDeploymentsInternalAPIInternalAPIAPI_DeploymentsInternalGetStorageUsageExecute_Call) Run(run func(r client.ApiDeploymentsInternalGetStorageUsageRequest)) *MockDeploymentsInternalAPIInternalAPIAPI_DeploymentsInternalGetStorageUsageExecute_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 client.ApiDeploymentsInternalGetStorageUsageRequest
		if args[0] != nil {
			arg0 = args[0].(client.ApiDeploymentsInternalGetStorageUsageRequest)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *MockDeploymentsInternalAPIInternalAPIAPI_DeploymentsInternalGetStorageUsageExecute_Call) Return(storageUsage *client.StorageUsage, response *http.Response, err error) *MockDeploymentsInternalAPIInternalAPIAPI_DeploymentsInternalGetStorageUsageExecute_Call {
	_c.Call.Return(storageUsage, response, err)
	return _c
}

func (_c *MockDeploymentsInternalAPIInternalAPIAPI_DeploymentsInternalGetStorageUsageExecute_Call) RunAndReturn(run func(r client.ApiDeploymentsInternalGetStorageUsageRequest) (*client.StorageUsage, *http.Response, error)) *MockDeploymentsInternalAPIInternalAPIAPI_DeploymentsInternalGetStorageUsageExecute_Call {
	_c.Call.Return(run)
	return _c
}

// DeploymentsInternalListDeploymentsForADevice provides a mock function for the type MockDeploymentsInternalAPIInternalAPIAPI
func (_mock *MockDeploymentsInternalAPIInternalAPIAPI) DeploymentsInternalListDeploymentsForADevice(ctx context.Context, tenantId string, id string) client.ApiDeploymentsInternalListDeploymentsForADeviceRequest {
	ret := _mock.Called(ctx, tenantId, id)

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

	var r0 client.ApiDeploymentsInternalListDeploymentsForADeviceRequest
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string) client.ApiDeploymentsInternalListDeploymentsForADeviceRequest); ok {
		r0 = returnFunc(ctx, tenantId, id)
	} else {
		r0 = ret.Get(0).(client.ApiDeploymentsInternalListDeploymentsForADeviceRequest)
	}
	return r0
}

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

// DeploymentsInternalListDeploymentsForADevice is a helper method to define mock.On call
//   - ctx context.Context
//   - tenantId string
//   - id string
func (_e *MockDeploymentsInternalAPIInternalAPIAPI_Expecter) DeploymentsInternalListDeploymentsForADevice(ctx interface{}, tenantId interface{}, id interface{}) *MockDeploymentsInternalAPIInternalAPIAPI_DeploymentsInternalListDeploymentsForADevice_Call {
	return &MockDeploymentsInternalAPIInternalAPIAPI_DeploymentsInternalListDeploymentsForADevice_Call{Call: _e.mock.On("DeploymentsInternalListDeploymentsForADevice", ctx, tenantId, id)}
}

func (_c *MockDeploymentsInternalAPIInternalAPIAPI_DeploymentsInternalListDeploymentsForADevice_Call) Run(run func(ctx context.Context, tenantId string, id string)) *MockDeploymentsInternalAPIInternalAPIAPI_DeploymentsInternalListDeploymentsForADevice_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)
		}
		run(
			arg0,
			arg1,
			arg2,
		)
	})
	return _c
}

func (_c *MockDeploymentsInternalAPIInternalAPIAPI_DeploymentsInternalListDeploymentsForADevice_Call) Return(apiDeploymentsInternalListDeploymentsForADeviceRequest client.ApiDeploymentsInternalListDeploymentsForADeviceRequest) *MockDeploymentsInternalAPIInternalAPIAPI_DeploymentsInternalListDeploymentsForADevice_Call {
	_c.Call.Return(apiDeploymentsInternalListDeploymentsForADeviceRequest)
	return _c
}

func (_c *MockDeploymentsInternalAPIInternalAPIAPI_DeploymentsInternalListDeploymentsForADevice_Call) RunAndReturn(run func(ctx context.Context, tenantId string, id string) client.ApiDeploymentsInternalListDeploymentsForADeviceRequest) *MockDeploymentsInternalAPIInternalAPIAPI_DeploymentsInternalListDeploymentsForADevice_Call {
	_c.Call.Return(run)
	return _c
}

// DeploymentsInternalListDeploymentsForADeviceExecute provides a mock function for the type MockDeploymentsInternalAPIInternalAPIAPI
func (_mock *MockDeploymentsInternalAPIInternalAPIAPI) DeploymentsInternalListDeploymentsForADeviceExecute(r client.ApiDeploymentsInternalListDeploymentsForADeviceRequest) ([]client.DeviceDeployment, *http.Response, error) {
	ret := _mock.Called(r)

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

	var r0 []client.DeviceDeployment
	var r1 *http.Response
	var r2 error
	if returnFunc, ok := ret.Get(0).(func(client.ApiDeploymentsInternalListDeploymentsForADeviceRequest) ([]client.DeviceDeployment, *http.Response, error)); ok {
		return returnFunc(r)
	}
	if returnFunc, ok := ret.Get(0).(func(client.ApiDeploymentsInternalListDeploymentsForADeviceRequest) []client.DeviceDeployment); ok {
		r0 = returnFunc(r)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]client.DeviceDeployment)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(client.ApiDeploymentsInternalListDeploymentsForADeviceRequest) *http.Response); ok {
		r1 = returnFunc(r)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*http.Response)
		}
	}
	if returnFunc, ok := ret.Get(2).(func(client.ApiDeploymentsInternalListDeploymentsForADeviceRequest) error); ok {
		r2 = returnFunc(r)
	} else {
		r2 = ret.Error(2)
	}
	return r0, r1, r2
}

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

// DeploymentsInternalListDeploymentsForADeviceExecute is a helper method to define mock.On call
//   - r client.ApiDeploymentsInternalListDeploymentsForADeviceRequest
func (_e *MockDeploymentsInternalAPIInternalAPIAPI_Expecter) DeploymentsInternalListDeploymentsForADeviceExecute(r interface{}) *MockDeploymentsInternalAPIInternalAPIAPI_DeploymentsInternalListDeploymentsForADeviceExecute_Call {
	return &MockDeploymentsInternalAPIInternalAPIAPI_DeploymentsInternalListDeploymentsForADeviceExecute_Call{Call: _e.mock.On("DeploymentsInternalListDeploymentsForADeviceExecute", r)}
}

func (_c *MockDeploymentsInternalAPIInternalAPIAPI_DeploymentsInternalListDeploymentsForADeviceExecute_Call) Run(run func(r client.ApiDeploymentsInternalListDeploymentsForADeviceRequest)) *MockDeploymentsInternalAPIInternalAPIAPI_DeploymentsInternalListDeploymentsForADeviceExecute_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 client.ApiDeploymentsInternalListDeploymentsForADeviceRequest
		if args[0] != nil {
			arg0 = args[0].(client.ApiDeploymentsInternalListDeploymentsForADeviceRequest)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *MockDeploymentsInternalAPIInternalAPIAPI_DeploymentsInternalListDeploymentsForADeviceExecute_Call) Return(deviceDeployments []client.DeviceDeployment, response *http.Response, err error) *MockDeploymentsInternalAPIInternalAPIAPI_DeploymentsInternalListDeploymentsForADeviceExecute_Call {
	_c.Call.Return(deviceDeployments, response, err)
	return _c
}

func (_c *MockDeploymentsInternalAPIInternalAPIAPI_DeploymentsInternalListDeploymentsForADeviceExecute_Call) RunAndReturn(run func(r client.ApiDeploymentsInternalListDeploymentsForADeviceRequest) ([]client.DeviceDeployment, *http.Response, error)) *MockDeploymentsInternalAPIInternalAPIAPI_DeploymentsInternalListDeploymentsForADeviceExecute_Call {
	_c.Call.Return(run)
	return _c
}

// DeploymentsInternalUploadArtifact provides a mock function for the type MockDeploymentsInternalAPIInternalAPIAPI
func (_mock *MockDeploymentsInternalAPIInternalAPIAPI) DeploymentsInternalUploadArtifact(ctx context.Context, id string) client.ApiDeploymentsInternalUploadArtifactRequest {
	ret := _mock.Called(ctx, id)

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

	var r0 client.ApiDeploymentsInternalUploadArtifactRequest
	if returnFunc, ok := ret.Get(0).(func(context.Context, string) client.ApiDeploymentsInternalUploadArtifactRequest); ok {
		r0 = returnFunc(ctx, id)
	} else {
		r0 = ret.Get(0).(client.ApiDeploymentsInternalUploadArtifactRequest)
	}
	return r0
}

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

// DeploymentsInternalUploadArtifact is a helper method to define mock.On call
//   - ctx context.Context
//   - id string
func (_e *MockDeploymentsInternalAPIInternalAPIAPI_Expecter) DeploymentsInternalUploadArtifact(ctx interface{}, id interface{}) *MockDeploymentsInternalAPIInternalAPIAPI_DeploymentsInternalUploadArtifact_Call {
	return &MockDeploymentsInternalAPIInternalAPIAPI_DeploymentsInternalUploadArtifact_Call{Call: _e.mock.On("DeploymentsInternalUploadArtifact", ctx, id)}
}

func (_c *MockDeploymentsInternalAPIInternalAPIAPI_DeploymentsInternalUploadArtifact_Call) Run(run func(ctx context.Context, id string)) *MockDeploymentsInternalAPIInternalAPIAPI_DeploymentsInternalUploadArtifact_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 *MockDeploymentsInternalAPIInternalAPIAPI_DeploymentsInternalUploadArtifact_Call) Return(apiDeploymentsInternalUploadArtifactRequest client.ApiDeploymentsInternalUploadArtifactRequest) *MockDeploymentsInternalAPIInternalAPIAPI_DeploymentsInternalUploadArtifact_Call {
	_c.Call.Return(apiDeploymentsInternalUploadArtifactRequest)
	return _c
}

func (_c *MockDeploymentsInternalAPIInternalAPIAPI_DeploymentsInternalUploadArtifact_Call) RunAndReturn(run func(ctx context.Context, id string) client.ApiDeploymentsInternalUploadArtifactRequest) *MockDeploymentsInternalAPIInternalAPIAPI_DeploymentsInternalUploadArtifact_Call {
	_c.Call.Return(run)
	return _c
}

// DeploymentsInternalUploadArtifactExecute provides a mock function for the type MockDeploymentsInternalAPIInternalAPIAPI
func (_mock *MockDeploymentsInternalAPIInternalAPIAPI) DeploymentsInternalUploadArtifactExecute(r client.ApiDeploymentsInternalUploadArtifactRequest) (*http.Response, error) {
	ret := _mock.Called(r)

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

	var r0 *http.Response
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(client.ApiDeploymentsInternalUploadArtifactRequest) (*http.Response, error)); ok {
		return returnFunc(r)
	}
	if returnFunc, ok := ret.Get(0).(func(client.ApiDeploymentsInternalUploadArtifactRequest) *http.Response); ok {
		r0 = returnFunc(r)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*http.Response)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(client.ApiDeploymentsInternalUploadArtifactRequest) error); ok {
		r1 = returnFunc(r)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// DeploymentsInternalUploadArtifactExecute is a helper method to define mock.On call
//   - r client.ApiDeploymentsInternalUploadArtifactRequest
func (_e *MockDeploymentsInternalAPIInternalAPIAPI_Expecter) DeploymentsInternalUploadArtifactExecute(r interface{}) *MockDeploymentsInternalAPIInternalAPIAPI_DeploymentsInternalUploadArtifactExecute_Call {
	return &MockDeploymentsInternalAPIInternalAPIAPI_DeploymentsInternalUploadArtifactExecute_Call{Call: _e.mock.On("DeploymentsInternalUploadArtifactExecute", r)}
}

func (_c *MockDeploymentsInternalAPIInternalAPIAPI_DeploymentsInternalUploadArtifactExecute_Call) Run(run func(r client.ApiDeploymentsInternalUploadArtifactRequest)) *MockDeploymentsInternalAPIInternalAPIAPI_DeploymentsInternalUploadArtifactExecute_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 client.ApiDeploymentsInternalUploadArtifactRequest
		if args[0] != nil {
			arg0 = args[0].(client.ApiDeploymentsInternalUploadArtifactRequest)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *MockDeploymentsInternalAPIInternalAPIAPI_DeploymentsInternalUploadArtifactExecute_Call) Return(response *http.Response, err error) *MockDeploymentsInternalAPIInternalAPIAPI_DeploymentsInternalUploadArtifactExecute_Call {
	_c.Call.Return(response, err)
	return _c
}

func (_c *MockDeploymentsInternalAPIInternalAPIAPI_DeploymentsInternalUploadArtifactExecute_Call) RunAndReturn(run func(r client.ApiDeploymentsInternalUploadArtifactRequest) (*http.Response, error)) *MockDeploymentsInternalAPIInternalAPIAPI_DeploymentsInternalUploadArtifactExecute_Call {
	_c.Call.Return(run)
	return _c
}

// GetDeployments provides a mock function for the type MockDeploymentsInternalAPIInternalAPIAPI
func (_mock *MockDeploymentsInternalAPIInternalAPIAPI) GetDeployments(ctx context.Context, id string) client.ApiGetDeploymentsRequest {
	ret := _mock.Called(ctx, id)

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

	var r0 client.ApiGetDeploymentsRequest
	if returnFunc, ok := ret.Get(0).(func(context.Context, string) client.ApiGetDeploymentsRequest); ok {
		r0 = returnFunc(ctx, id)
	} else {
		r0 = ret.Get(0).(client.ApiGetDeploymentsRequest)
	}
	return r0
}

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

// GetDeployments is a helper method to define mock.On call
//   - ctx context.Context
//   - id string
func (_e *MockDeploymentsInternalAPIInternalAPIAPI_Expecter) GetDeployments(ctx interface{}, id interface{}) *MockDeploymentsInternalAPIInternalAPIAPI_GetDeployments_Call {
	return &MockDeploymentsInternalAPIInternalAPIAPI_GetDeployments_Call{Call: _e.mock.On("GetDeployments", ctx, id)}
}

func (_c *MockDeploymentsInternalAPIInternalAPIAPI_GetDeployments_Call) Run(run func(ctx context.Context, id string)) *MockDeploymentsInternalAPIInternalAPIAPI_GetDeployments_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 *MockDeploymentsInternalAPIInternalAPIAPI_GetDeployments_Call) Return(apiGetDeploymentsRequest client.ApiGetDeploymentsRequest) *MockDeploymentsInternalAPIInternalAPIAPI_GetDeployments_Call {
	_c.Call.Return(apiGetDeploymentsRequest)
	return _c
}

func (_c *MockDeploymentsInternalAPIInternalAPIAPI_GetDeployments_Call) RunAndReturn(run func(ctx context.Context, id string) client.ApiGetDeploymentsRequest) *MockDeploymentsInternalAPIInternalAPIAPI_GetDeployments_Call {
	_c.Call.Return(run)
	return _c
}

// GetDeploymentsExecute provides a mock function for the type MockDeploymentsInternalAPIInternalAPIAPI
func (_mock *MockDeploymentsInternalAPIInternalAPIAPI) GetDeploymentsExecute(r client.ApiGetDeploymentsRequest) ([]client.DeploymentV1Internal, *http.Response, error) {
	ret := _mock.Called(r)

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

	var r0 []client.DeploymentV1Internal
	var r1 *http.Response
	var r2 error
	if returnFunc, ok := ret.Get(0).(func(client.ApiGetDeploymentsRequest) ([]client.DeploymentV1Internal, *http.Response, error)); ok {
		return returnFunc(r)
	}
	if returnFunc, ok := ret.Get(0).(func(client.ApiGetDeploymentsRequest) []client.DeploymentV1Internal); ok {
		r0 = returnFunc(r)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]client.DeploymentV1Internal)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(client.ApiGetDeploymentsRequest) *http.Response); ok {
		r1 = returnFunc(r)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*http.Response)
		}
	}
	if returnFunc, ok := ret.Get(2).(func(client.ApiGetDeploymentsRequest) error); ok {
		r2 = returnFunc(r)
	} else {
		r2 = ret.Error(2)
	}
	return r0, r1, r2
}

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

// GetDeploymentsExecute is a helper method to define mock.On call
//   - r client.ApiGetDeploymentsRequest
func (_e *MockDeploymentsInternalAPIInternalAPIAPI_Expecter) GetDeploymentsExecute(r interface{}) *MockDeploymentsInternalAPIInternalAPIAPI_GetDeploymentsExecute_Call {
	return &MockDeploymentsInternalAPIInternalAPIAPI_GetDeploymentsExecute_Call{Call: _e.mock.On("GetDeploymentsExecute", r)}
}

func (_c *MockDeploymentsInternalAPIInternalAPIAPI_GetDeploymentsExecute_Call) Run(run func(r client.ApiGetDeploymentsRequest)) *MockDeploymentsInternalAPIInternalAPIAPI_GetDeploymentsExecute_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 client.ApiGetDeploymentsRequest
		if args[0] != nil {
			arg0 = args[0].(client.ApiGetDeploymentsRequest)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *MockDeploymentsInternalAPIInternalAPIAPI_GetDeploymentsExecute_Call) Return(deploymentV1Internals []client.DeploymentV1Internal, response *http.Response, err error) *MockDeploymentsInternalAPIInternalAPIAPI_GetDeploymentsExecute_Call {
	_c.Call.Return(deploymentV1Internals, response, err)
	return _c
}

func (_c *MockDeploymentsInternalAPIInternalAPIAPI_GetDeploymentsExecute_Call) RunAndReturn(run func(r client.ApiGetDeploymentsRequest) ([]client.DeploymentV1Internal, *http.Response, error)) *MockDeploymentsInternalAPIInternalAPIAPI_GetDeploymentsExecute_Call {
	_c.Call.Return(run)
	return _c
}

// GetLastDeviceDeploymentStatus provides a mock function for the type MockDeploymentsInternalAPIInternalAPIAPI
func (_mock *MockDeploymentsInternalAPIInternalAPIAPI) GetLastDeviceDeploymentStatus(ctx context.Context, tenantId string) client.ApiGetLastDeviceDeploymentStatusRequest {
	ret := _mock.Called(ctx, tenantId)

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

	var r0 client.ApiGetLastDeviceDeploymentStatusRequest
	if returnFunc, ok := ret.Get(0).(func(context.Context, string) client.ApiGetLastDeviceDeploymentStatusRequest); ok {
		r0 = returnFunc(ctx, tenantId)
	} else {
		r0 = ret.Get(0).(client.ApiGetLastDeviceDeploymentStatusRequest)
	}
	return r0
}

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

// GetLastDeviceDeploymentStatus is a helper method to define mock.On call
//   - ctx context.Context
//   - tenantId string
func (_e *MockDeploymentsInternalAPIInternalAPIAPI_Expecter) GetLastDeviceDeploymentStatus(ctx interface{}, tenantId interface{}) *MockDeploymentsInternalAPIInternalAPIAPI_GetLastDeviceDeploymentStatus_Call {
	return &MockDeploymentsInternalAPIInternalAPIAPI_GetLastDeviceDeploymentStatus_Call{Call: _e.mock.On("GetLastDeviceDeploymentStatus", ctx, tenantId)}
}

func (_c *MockDeploymentsInternalAPIInternalAPIAPI_GetLastDeviceDeploymentStatus_Call) Run(run func(ctx context.Context, tenantId string)) *MockDeploymentsInternalAPIInternalAPIAPI_GetLastDeviceDeploymentStatus_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 *MockDeploymentsInternalAPIInternalAPIAPI_GetLastDeviceDeploymentStatus_Call) Return(apiGetLastDeviceDeploymentStatusRequest client.ApiGetLastDeviceDeploymentStatusRequest) *MockDeploymentsInternalAPIInternalAPIAPI_GetLastDeviceDeploymentStatus_Call {
	_c.Call.Return(apiGetLastDeviceDeploymentStatusRequest)
	return _c
}

func (_c *MockDeploymentsInternalAPIInternalAPIAPI_GetLastDeviceDeploymentStatus_Call) RunAndReturn(run func(ctx context.Context, tenantId string) client.ApiGetLastDeviceDeploymentStatusRequest) *MockDeploymentsInternalAPIInternalAPIAPI_GetLastDeviceDeploymentStatus_Call {
	_c.Call.Return(run)
	return _c
}

// GetLastDeviceDeploymentStatusExecute provides a mock function for the type MockDeploymentsInternalAPIInternalAPIAPI
func (_mock *MockDeploymentsInternalAPIInternalAPIAPI) GetLastDeviceDeploymentStatusExecute(r client.ApiGetLastDeviceDeploymentStatusRequest) (*client.LastDeviceDeploymentsStatuses, *http.Response, error) {
	ret := _mock.Called(r)

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

	var r0 *client.LastDeviceDeploymentsStatuses
	var r1 *http.Response
	var r2 error
	if returnFunc, ok := ret.Get(0).(func(client.ApiGetLastDeviceDeploymentStatusRequest) (*client.LastDeviceDeploymentsStatuses, *http.Response, error)); ok {
		return returnFunc(r)
	}
	if returnFunc, ok := ret.Get(0).(func(client.ApiGetLastDeviceDeploymentStatusRequest) *client.LastDeviceDeploymentsStatuses); ok {
		r0 = returnFunc(r)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*client.LastDeviceDeploymentsStatuses)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(client.ApiGetLastDeviceDeploymentStatusRequest) *http.Response); ok {
		r1 = returnFunc(r)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*http.Response)
		}
	}
	if returnFunc, ok := ret.Get(2).(func(client.ApiGetLastDeviceDeploymentStatusRequest) error); ok {
		r2 = returnFunc(r)
	} else {
		r2 = ret.Error(2)
	}
	return r0, r1, r2
}

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

// GetLastDeviceDeploymentStatusExecute is a helper method to define mock.On call
//   - r client.ApiGetLastDeviceDeploymentStatusRequest
func (_e *MockDeploymentsInternalAPIInternalAPIAPI_Expecter) GetLastDeviceDeploymentStatusExecute(r interface{}) *MockDeploymentsInternalAPIInternalAPIAPI_GetLastDeviceDeploymentStatusExecute_Call {
	return &MockDeploymentsInternalAPIInternalAPIAPI_GetLastDeviceDeploymentStatusExecute_Call{Call: _e.mock.On("GetLastDeviceDeploymentStatusExecute", r)}
}

func (_c *MockDeploymentsInternalAPIInternalAPIAPI_GetLastDeviceDeploymentStatusExecute_Call) Run(run func(r client.ApiGetLastDeviceDeploymentStatusRequest)) *MockDeploymentsInternalAPIInternalAPIAPI_GetLastDeviceDeploymentStatusExecute_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 client.ApiGetLastDeviceDeploymentStatusRequest
		if args[0] != nil {
			arg0 = args[0].(client.ApiGetLastDeviceDeploymentStatusRequest)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *MockDeploymentsInternalAPIInternalAPIAPI_GetLastDeviceDeploymentStatusExecute_Call) Return(lastDeviceDeploymentsStatuses *client.LastDeviceDeploymentsStatuses, response *http.Response, err error) *MockDeploymentsInternalAPIInternalAPIAPI_GetLastDeviceDeploymentStatusExecute_Call {
	_c.Call.Return(lastDeviceDeploymentsStatuses, response, err)
	return _c
}

func (_c *MockDeploymentsInternalAPIInternalAPIAPI_GetLastDeviceDeploymentStatusExecute_Call) RunAndReturn(run func(r client.ApiGetLastDeviceDeploymentStatusRequest) (*client.LastDeviceDeploymentsStatuses, *http.Response, error)) *MockDeploymentsInternalAPIInternalAPIAPI_GetLastDeviceDeploymentStatusExecute_Call {
	_c.Call.Return(run)
	return _c
}

// GetStorageSettings provides a mock function for the type MockDeploymentsInternalAPIInternalAPIAPI
func (_mock *MockDeploymentsInternalAPIInternalAPIAPI) GetStorageSettings(ctx context.Context, id string) client.ApiGetStorageSettingsRequest {
	ret := _mock.Called(ctx, id)

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

	var r0 client.ApiGetStorageSettingsRequest
	if returnFunc, ok := ret.Get(0).(func(context.Context, string) client.ApiGetStorageSettingsRequest); ok {
		r0 = returnFunc(ctx, id)
	} else {
		r0 = ret.Get(0).(client.ApiGetStorageSettingsRequest)
	}
	return r0
}

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

// GetStorageSettings is a helper method to define mock.On call
//   - ctx context.Context
//   - id string
func (_e *MockDeploymentsInternalAPIInternalAPIAPI_Expecter) GetStorageSettings(ctx interface{}, id interface{}) *MockDeploymentsInternalAPIInternalAPIAPI_GetStorageSettings_Call {
	return &MockDeploymentsInternalAPIInternalAPIAPI_GetStorageSettings_Call{Call: _e.mock.On("GetStorageSettings", ctx, id)}
}

func (_c *MockDeploymentsInternalAPIInternalAPIAPI_GetStorageSettings_Call) Run(run func(ctx context.Context, id string)) *MockDeploymentsInternalAPIInternalAPIAPI_GetStorageSettings_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 *MockDeploymentsInternalAPIInternalAPIAPI_GetStorageSettings_Call) Return(apiGetStorageSettingsRequest client.ApiGetStorageSettingsRequest) *MockDeploymentsInternalAPIInternalAPIAPI_GetStorageSettings_Call {
	_c.Call.Return(apiGetStorageSettingsRequest)
	return _c
}

func (_c *MockDeploymentsInternalAPIInternalAPIAPI_GetStorageSettings_Call) RunAndReturn(run func(ctx context.Context, id string) client.ApiGetStorageSettingsRequest) *MockDeploymentsInternalAPIInternalAPIAPI_GetStorageSettings_Call {
	_c.Call.Return(run)
	return _c
}

// GetStorageSettingsExecute provides a mock function for the type MockDeploymentsInternalAPIInternalAPIAPI
func (_mock *MockDeploymentsInternalAPIInternalAPIAPI) GetStorageSettingsExecute(r client.ApiGetStorageSettingsRequest) (*client.StorageSettings, *http.Response, error) {
	ret := _mock.Called(r)

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

	var r0 *client.StorageSettings
	var r1 *http.Response
	var r2 error
	if returnFunc, ok := ret.Get(0).(func(client.ApiGetStorageSettingsRequest) (*client.StorageSettings, *http.Response, error)); ok {
		return returnFunc(r)
	}
	if returnFunc, ok := ret.Get(0).(func(client.ApiGetStorageSettingsRequest) *client.StorageSettings); ok {
		r0 = returnFunc(r)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*client.StorageSettings)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(client.ApiGetStorageSettingsRequest) *http.Response); ok {
		r1 = returnFunc(r)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*http.Response)
		}
	}
	if returnFunc, ok := ret.Get(2).(func(client.ApiGetStorageSettingsRequest) error); ok {
		r2 = returnFunc(r)
	} else {
		r2 = ret.Error(2)
	}
	return r0, r1, r2
}

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

// GetStorageSettingsExecute is a helper method to define mock.On call
//   - r client.ApiGetStorageSettingsRequest
func (_e *MockDeploymentsInternalAPIInternalAPIAPI_Expecter) GetStorageSettingsExecute(r interface{}) *MockDeploymentsInternalAPIInternalAPIAPI_GetStorageSettingsExecute_Call {
	return &MockDeploymentsInternalAPIInternalAPIAPI_GetStorageSettingsExecute_Call{Call: _e.mock.On("GetStorageSettingsExecute", r)}
}

func (_c *MockDeploymentsInternalAPIInternalAPIAPI_GetStorageSettingsExecute_Call) Run(run func(r client.ApiGetStorageSettingsRequest)) *MockDeploymentsInternalAPIInternalAPIAPI_GetStorageSettingsExecute_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 client.ApiGetStorageSettingsRequest
		if args[0] != nil {
			arg0 = args[0].(client.ApiGetStorageSettingsRequest)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *MockDeploymentsInternalAPIInternalAPIAPI_GetStorageSettingsExecute_Call) Return(storageSettings *client.StorageSettings, response *http.Response, err error) *MockDeploymentsInternalAPIInternalAPIAPI_GetStorageSettingsExecute_Call {
	_c.Call.Return(storageSettings, response, err)
	return _c
}

func (_c *MockDeploymentsInternalAPIInternalAPIAPI_GetStorageSettingsExecute_Call) RunAndReturn(run func(r client.ApiGetStorageSettingsRequest) (*client.StorageSettings, *http.Response, error)) *MockDeploymentsInternalAPIInternalAPIAPI_GetStorageSettingsExecute_Call {
	_c.Call.Return(run)
	return _c
}

// ListDeviceDeploymentsEntries provides a mock function for the type MockDeploymentsInternalAPIInternalAPIAPI
func (_mock *MockDeploymentsInternalAPIInternalAPIAPI) ListDeviceDeploymentsEntries(ctx context.Context, tenantId string) client.ApiListDeviceDeploymentsEntriesRequest {
	ret := _mock.Called(ctx, tenantId)

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

	var r0 client.ApiListDeviceDeploymentsEntriesRequest
	if returnFunc, ok := ret.Get(0).(func(context.Context, string) client.ApiListDeviceDeploymentsEntriesRequest); ok {
		r0 = returnFunc(ctx, tenantId)
	} else {
		r0 = ret.Get(0).(client.ApiListDeviceDeploymentsEntriesRequest)
	}
	return r0
}

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

// ListDeviceDeploymentsEntries is a helper method to define mock.On call
//   - ctx context.Context
//   - tenantId string
func (_e *MockDeploymentsInternalAPIInternalAPIAPI_Expecter) ListDeviceDeploymentsEntries(ctx interface{}, tenantId interface{}) *MockDeploymentsInternalAPIInternalAPIAPI_ListDeviceDeploymentsEntries_Call {
	return &MockDeploymentsInternalAPIInternalAPIAPI_ListDeviceDeploymentsEntries_Call{Call: _e.mock.On("ListDeviceDeploymentsEntries", ctx, tenantId)}
}

func (_c *MockDeploymentsInternalAPIInternalAPIAPI_ListDeviceDeploymentsEntries_Call) Run(run func(ctx context.Context, tenantId string)) *MockDeploymentsInternalAPIInternalAPIAPI_ListDeviceDeploymentsEntries_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 *MockDeploymentsInternalAPIInternalAPIAPI_ListDeviceDeploymentsEntries_Call) Return(apiListDeviceDeploymentsEntriesRequest client.ApiListDeviceDeploymentsEntriesRequest) *MockDeploymentsInternalAPIInternalAPIAPI_ListDeviceDeploymentsEntries_Call {
	_c.Call.Return(apiListDeviceDeploymentsEntriesRequest)
	return _c
}

func (_c *MockDeploymentsInternalAPIInternalAPIAPI_ListDeviceDeploymentsEntries_Call) RunAndReturn(run func(ctx context.Context, tenantId string) client.ApiListDeviceDeploymentsEntriesRequest) *MockDeploymentsInternalAPIInternalAPIAPI_ListDeviceDeploymentsEntries_Call {
	_c.Call.Return(run)
	return _c
}

// ListDeviceDeploymentsEntriesExecute provides a mock function for the type MockDeploymentsInternalAPIInternalAPIAPI
func (_mock *MockDeploymentsInternalAPIInternalAPIAPI) ListDeviceDeploymentsEntriesExecute(r client.ApiListDeviceDeploymentsEntriesRequest) ([]client.DeviceDeployment, *http.Response, error) {
	ret := _mock.Called(r)

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

	var r0 []client.DeviceDeployment
	var r1 *http.Response
	var r2 error
	if returnFunc, ok := ret.Get(0).(func(client.ApiListDeviceDeploymentsEntriesRequest) ([]client.DeviceDeployment, *http.Response, error)); ok {
		return returnFunc(r)
	}
	if returnFunc, ok := ret.Get(0).(func(client.ApiListDeviceDeploymentsEntriesRequest) []client.DeviceDeployment); ok {
		r0 = returnFunc(r)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]client.DeviceDeployment)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(client.ApiListDeviceDeploymentsEntriesRequest) *http.Response); ok {
		r1 = returnFunc(r)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*http.Response)
		}
	}
	if returnFunc, ok := ret.Get(2).(func(client.ApiListDeviceDeploymentsEntriesRequest) error); ok {
		r2 = returnFunc(r)
	} else {
		r2 = ret.Error(2)
	}
	return r0, r1, r2
}

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

// ListDeviceDeploymentsEntriesExecute is a helper method to define mock.On call
//   - r client.ApiListDeviceDeploymentsEntriesRequest
func (_e *MockDeploymentsInternalAPIInternalAPIAPI_Expecter) ListDeviceDeploymentsEntriesExecute(r interface{}) *MockDeploymentsInternalAPIInternalAPIAPI_ListDeviceDeploymentsEntriesExecute_Call {
	return &MockDeploymentsInternalAPIInternalAPIAPI_ListDeviceDeploymentsEntriesExecute_Call{Call: _e.mock.On("ListDeviceDeploymentsEntriesExecute", r)}
}

func (_c *MockDeploymentsInternalAPIInternalAPIAPI_ListDeviceDeploymentsEntriesExecute_Call) Run(run func(r client.ApiListDeviceDeploymentsEntriesRequest)) *MockDeploymentsInternalAPIInternalAPIAPI_ListDeviceDeploymentsEntriesExecute_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 client.ApiListDeviceDeploymentsEntriesRequest
		if args[0] != nil {
			arg0 = args[0].(client.ApiListDeviceDeploymentsEntriesRequest)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *MockDeploymentsInternalAPIInternalAPIAPI_ListDeviceDeploymentsEntriesExecute_Call) Return(deviceDeployments []client.DeviceDeployment, response *http.Response, err error) *MockDeploymentsInternalAPIInternalAPIAPI_ListDeviceDeploymentsEntriesExecute_Call {
	_c.Call.Return(deviceDeployments, response, err)
	return _c
}

func (_c *MockDeploymentsInternalAPIInternalAPIAPI_ListDeviceDeploymentsEntriesExecute_Call) RunAndReturn(run func(r client.ApiListDeviceDeploymentsEntriesRequest) ([]client.DeviceDeployment, *http.Response, error)) *MockDeploymentsInternalAPIInternalAPIAPI_ListDeviceDeploymentsEntriesExecute_Call {
	_c.Call.Return(run)
	return _c
}

// RemoveDeviceFromDeployments provides a mock function for the type MockDeploymentsInternalAPIInternalAPIAPI
func (_mock *MockDeploymentsInternalAPIInternalAPIAPI) RemoveDeviceFromDeployments(ctx context.Context, tenantId string, id string) client.ApiRemoveDeviceFromDeploymentsRequest {
	ret := _mock.Called(ctx, tenantId, id)

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

	var r0 client.ApiRemoveDeviceFromDeploymentsRequest
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string) client.ApiRemoveDeviceFromDeploymentsRequest); ok {
		r0 = returnFunc(ctx, tenantId, id)
	} else {
		r0 = ret.Get(0).(client.ApiRemoveDeviceFromDeploymentsRequest)
	}
	return r0
}

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

// RemoveDeviceFromDeployments is a helper method to define mock.On call
//   - ctx context.Context
//   - tenantId string
//   - id string
func (_e *MockDeploymentsInternalAPIInternalAPIAPI_Expecter) RemoveDeviceFromDeployments(ctx interface{}, tenantId interface{}, id interface{}) *MockDeploymentsInternalAPIInternalAPIAPI_RemoveDeviceFromDeployments_Call {
	return &MockDeploymentsInternalAPIInternalAPIAPI_RemoveDeviceFromDeployments_Call{Call: _e.mock.On("RemoveDeviceFromDeployments", ctx, tenantId, id)}
}

func (_c *MockDeploymentsInternalAPIInternalAPIAPI_RemoveDeviceFromDeployments_Call) Run(run func(ctx context.Context, tenantId string, id string)) *MockDeploymentsInternalAPIInternalAPIAPI_RemoveDeviceFromDeployments_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)
		}
		run(
			arg0,
			arg1,
			arg2,
		)
	})
	return _c
}

func (_c *MockDeploymentsInternalAPIInternalAPIAPI_RemoveDeviceFromDeployments_Call) Return(apiRemoveDeviceFromDeploymentsRequest client.ApiRemoveDeviceFromDeploymentsRequest) *MockDeploymentsInternalAPIInternalAPIAPI_RemoveDeviceFromDeployments_Call {
	_c.Call.Return(apiRemoveDeviceFromDeploymentsRequest)
	return _c
}

func (_c *MockDeploymentsInternalAPIInternalAPIAPI_RemoveDeviceFromDeployments_Call) RunAndReturn(run func(ctx context.Context, tenantId string, id string) client.ApiRemoveDeviceFromDeploymentsRequest) *MockDeploymentsInternalAPIInternalAPIAPI_RemoveDeviceFromDeployments_Call {
	_c.Call.Return(run)
	return _c
}

// RemoveDeviceFromDeploymentsExecute provides a mock function for the type MockDeploymentsInternalAPIInternalAPIAPI
func (_mock *MockDeploymentsInternalAPIInternalAPIAPI) RemoveDeviceFromDeploymentsExecute(r client.ApiRemoveDeviceFromDeploymentsRequest) (*http.Response, error) {
	ret := _mock.Called(r)

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

	var r0 *http.Response
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(client.ApiRemoveDeviceFromDeploymentsRequest) (*http.Response, error)); ok {
		return returnFunc(r)
	}
	if returnFunc, ok := ret.Get(0).(func(client.ApiRemoveDeviceFromDeploymentsRequest) *http.Response); ok {
		r0 = returnFunc(r)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*http.Response)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(client.ApiRemoveDeviceFromDeploymentsRequest) error); ok {
		r1 = returnFunc(r)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// RemoveDeviceFromDeploymentsExecute is a helper method to define mock.On call
//   - r client.ApiRemoveDeviceFromDeploymentsRequest
func (_e *MockDeploymentsInternalAPIInternalAPIAPI_Expecter) RemoveDeviceFromDeploymentsExecute(r interface{}) *MockDeploymentsInternalAPIInternalAPIAPI_RemoveDeviceFromDeploymentsExecute_Call {
	return &MockDeploymentsInternalAPIInternalAPIAPI_RemoveDeviceFromDeploymentsExecute_Call{Call: _e.mock.On("RemoveDeviceFromDeploymentsExecute", r)}
}

func (_c *MockDeploymentsInternalAPIInternalAPIAPI_RemoveDeviceFromDeploymentsExecute_Call) Run(run func(r client.ApiRemoveDeviceFromDeploymentsRequest)) *MockDeploymentsInternalAPIInternalAPIAPI_RemoveDeviceFromDeploymentsExecute_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 client.ApiRemoveDeviceFromDeploymentsRequest
		if args[0] != nil {
			arg0 = args[0].(client.ApiRemoveDeviceFromDeploymentsRequest)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *MockDeploymentsInternalAPIInternalAPIAPI_RemoveDeviceFromDeploymentsExecute_Call) Return(response *http.Response, err error) *MockDeploymentsInternalAPIInternalAPIAPI_RemoveDeviceFromDeploymentsExecute_Call {
	_c.Call.Return(response, err)
	return _c
}

func (_c *MockDeploymentsInternalAPIInternalAPIAPI_RemoveDeviceFromDeploymentsExecute_Call) RunAndReturn(run func(r client.ApiRemoveDeviceFromDeploymentsRequest) (*http.Response, error)) *MockDeploymentsInternalAPIInternalAPIAPI_RemoveDeviceFromDeploymentsExecute_Call {
	_c.Call.Return(run)
	return _c
}

// SetStorageLimit provides a mock function for the type MockDeploymentsInternalAPIInternalAPIAPI
func (_mock *MockDeploymentsInternalAPIInternalAPIAPI) SetStorageLimit(ctx context.Context, id string) client.ApiSetStorageLimitRequest {
	ret := _mock.Called(ctx, id)

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

	var r0 client.ApiSetStorageLimitRequest
	if returnFunc, ok := ret.Get(0).(func(context.Context, string) client.ApiSetStorageLimitRequest); ok {
		r0 = returnFunc(ctx, id)
	} else {
		r0 = ret.Get(0).(client.ApiSetStorageLimitRequest)
	}
	return r0
}

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

// SetStorageLimit is a helper method to define mock.On call
//   - ctx context.Context
//   - id string
func (_e *MockDeploymentsInternalAPIInternalAPIAPI_Expecter) SetStorageLimit(ctx interface{}, id interface{}) *MockDeploymentsInternalAPIInternalAPIAPI_SetStorageLimit_Call {
	return &MockDeploymentsInternalAPIInternalAPIAPI_SetStorageLimit_Call{Call: _e.mock.On("SetStorageLimit", ctx, id)}
}

func (_c *MockDeploymentsInternalAPIInternalAPIAPI_SetStorageLimit_Call) Run(run func(ctx context.Context, id string)) *MockDeploymentsInternalAPIInternalAPIAPI_SetStorageLimit_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 *MockDeploymentsInternalAPIInternalAPIAPI_SetStorageLimit_Call) Return(apiSetStorageLimitRequest client.ApiSetStorageLimitRequest) *MockDeploymentsInternalAPIInternalAPIAPI_SetStorageLimit_Call {
	_c.Call.Return(apiSetStorageLimitRequest)
	return _c
}

func (_c *MockDeploymentsInternalAPIInternalAPIAPI_SetStorageLimit_Call) RunAndReturn(run func(ctx context.Context, id string) client.ApiSetStorageLimitRequest) *MockDeploymentsInternalAPIInternalAPIAPI_SetStorageLimit_Call {
	_c.Call.Return(run)
	return _c
}

// SetStorageLimitExecute provides a mock function for the type MockDeploymentsInternalAPIInternalAPIAPI
func (_mock *MockDeploymentsInternalAPIInternalAPIAPI) SetStorageLimitExecute(r client.ApiSetStorageLimitRequest) (*http.Response, error) {
	ret := _mock.Called(r)

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

	var r0 *http.Response
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(client.ApiSetStorageLimitRequest) (*http.Response, error)); ok {
		return returnFunc(r)
	}
	if returnFunc, ok := ret.Get(0).(func(client.ApiSetStorageLimitRequest) *http.Response); ok {
		r0 = returnFunc(r)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*http.Response)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(client.ApiSetStorageLimitRequest) error); ok {
		r1 = returnFunc(r)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// SetStorageLimitExecute is a helper method to define mock.On call
//   - r client.ApiSetStorageLimitRequest
func (_e *MockDeploymentsInternalAPIInternalAPIAPI_Expecter) SetStorageLimitExecute(r interface{}) *MockDeploymentsInternalAPIInternalAPIAPI_SetStorageLimitExecute_Call {
	return &MockDeploymentsInternalAPIInternalAPIAPI_SetStorageLimitExecute_Call{Call: _e.mock.On("SetStorageLimitExecute", r)}
}

func (_c *MockDeploymentsInternalAPIInternalAPIAPI_SetStorageLimitExecute_Call) Run(run func(r client.ApiSetStorageLimitRequest)) *MockDeploymentsInternalAPIInternalAPIAPI_SetStorageLimitExecute_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 client.ApiSetStorageLimitRequest
		if args[0] != nil {
			arg0 = args[0].(client.ApiSetStorageLimitRequest)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *MockDeploymentsInternalAPIInternalAPIAPI_SetStorageLimitExecute_Call) Return(response *http.Response, err error) *MockDeploymentsInternalAPIInternalAPIAPI_SetStorageLimitExecute_Call {
	_c.Call.Return(response, err)
	return _c
}

func (_c *MockDeploymentsInternalAPIInternalAPIAPI_SetStorageLimitExecute_Call) RunAndReturn(run func(r client.ApiSetStorageLimitRequest) (*http.Response, error)) *MockDeploymentsInternalAPIInternalAPIAPI_SetStorageLimitExecute_Call {
	_c.Call.Return(run)
	return _c
}

// SetStorageSettings provides a mock function for the type MockDeploymentsInternalAPIInternalAPIAPI
func (_mock *MockDeploymentsInternalAPIInternalAPIAPI) SetStorageSettings(ctx context.Context, id string) client.ApiSetStorageSettingsRequest {
	ret := _mock.Called(ctx, id)

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

	var r0 client.ApiSetStorageSettingsRequest
	if returnFunc, ok := ret.Get(0).(func(context.Context, string) client.ApiSetStorageSettingsRequest); ok {
		r0 = returnFunc(ctx, id)
	} else {
		r0 = ret.Get(0).(client.ApiSetStorageSettingsRequest)
	}
	return r0
}

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

// SetStorageSettings is a helper method to define mock.On call
//   - ctx context.Context
//   - id string
func (_e *MockDeploymentsInternalAPIInternalAPIAPI_Expecter) SetStorageSettings(ctx interface{}, id interface{}) *MockDeploymentsInternalAPIInternalAPIAPI_SetStorageSettings_Call {
	return &MockDeploymentsInternalAPIInternalAPIAPI_SetStorageSettings_Call{Call: _e.mock.On("SetStorageSettings", ctx, id)}
}

func (_c *MockDeploymentsInternalAPIInternalAPIAPI_SetStorageSettings_Call) Run(run func(ctx context.Context, id string)) *MockDeploymentsInternalAPIInternalAPIAPI_SetStorageSettings_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 *MockDeploymentsInternalAPIInternalAPIAPI_SetStorageSettings_Call) Return(apiSetStorageSettingsRequest client.ApiSetStorageSettingsRequest) *MockDeploymentsInternalAPIInternalAPIAPI_SetStorageSettings_Call {
	_c.Call.Return(apiSetStorageSettingsRequest)
	return _c
}

func (_c *MockDeploymentsInternalAPIInternalAPIAPI_SetStorageSettings_Call) RunAndReturn(run func(ctx context.Context, id string) client.ApiSetStorageSettingsRequest) *MockDeploymentsInternalAPIInternalAPIAPI_SetStorageSettings_Call {
	_c.Call.Return(run)
	return _c
}

// SetStorageSettingsExecute provides a mock function for the type MockDeploymentsInternalAPIInternalAPIAPI
func (_mock *MockDeploymentsInternalAPIInternalAPIAPI) SetStorageSettingsExecute(r client.ApiSetStorageSettingsRequest) (*http.Response, error) {
	ret := _mock.Called(r)

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

	var r0 *http.Response
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(client.ApiSetStorageSettingsRequest) (*http.Response, error)); ok {
		return returnFunc(r)
	}
	if returnFunc, ok := ret.Get(0).(func(client.ApiSetStorageSettingsRequest) *http.Response); ok {
		r0 = returnFunc(r)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*http.Response)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(client.ApiSetStorageSettingsRequest) error); ok {
		r1 = returnFunc(r)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// SetStorageSettingsExecute is a helper method to define mock.On call
//   - r client.ApiSetStorageSettingsRequest
func (_e *MockDeploymentsInternalAPIInternalAPIAPI_Expecter) SetStorageSettingsExecute(r interface{}) *MockDeploymentsInternalAPIInternalAPIAPI_SetStorageSettingsExecute_Call {
	return &MockDeploymentsInternalAPIInternalAPIAPI_SetStorageSettingsExecute_Call{Call: _e.mock.On("SetStorageSettingsExecute", r)}
}

func (_c *MockDeploymentsInternalAPIInternalAPIAPI_SetStorageSettingsExecute_Call) Run(run func(r client.ApiSetStorageSettingsRequest)) *MockDeploymentsInternalAPIInternalAPIAPI_SetStorageSettingsExecute_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 client.ApiSetStorageSettingsRequest
		if args[0] != nil {
			arg0 = args[0].(client.ApiSetStorageSettingsRequest)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *MockDeploymentsInternalAPIInternalAPIAPI_SetStorageSettingsExecute_Call) Return(response *http.Response, err error) *MockDeploymentsInternalAPIInternalAPIAPI_SetStorageSettingsExecute_Call {
	_c.Call.Return(response, err)
	return _c
}

func (_c *MockDeploymentsInternalAPIInternalAPIAPI_SetStorageSettingsExecute_Call) RunAndReturn(run func(r client.ApiSetStorageSettingsRequest) (*http.Response, error)) *MockDeploymentsInternalAPIInternalAPIAPI_SetStorageSettingsExecute_Call {
	_c.Call.Return(run)
	return _c
}

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

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

	return mock
}

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

type MockDeploymentsManagementAPIAPI_Expecter struct {
	mock *mock.Mock
}

func (_m *MockDeploymentsManagementAPIAPI) EXPECT() *MockDeploymentsManagementAPIAPI_Expecter {
	return &MockDeploymentsManagementAPIAPI_Expecter{mock: &_m.Mock}
}

// AbortDeployment provides a mock function for the type MockDeploymentsManagementAPIAPI
func (_mock *MockDeploymentsManagementAPIAPI) AbortDeployment(ctx context.Context, deploymentId string) client.ApiAbortDeploymentRequest {
	ret := _mock.Called(ctx, deploymentId)

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

	var r0 client.ApiAbortDeploymentRequest
	if returnFunc, ok := ret.Get(0).(func(context.Context, string) client.ApiAbortDeploymentRequest); ok {
		r0 = returnFunc(ctx, deploymentId)
	} else {
		r0 = ret.Get(0).(client.ApiAbortDeploymentRequest)
	}
	return r0
}

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

// AbortDeployment is a helper method to define mock.On call
//   - ctx context.Context
//   - deploymentId string
func (_e *MockDeploymentsManagementAPIAPI_Expecter) AbortDeployment(ctx interface{}, deploymentId interface{}) *MockDeploymentsManagementAPIAPI_AbortDeployment_Call {
	return &MockDeploymentsManagementAPIAPI_AbortDeployment_Call{Call: _e.mock.On("AbortDeployment", ctx, deploymentId)}
}

func (_c *MockDeploymentsManagementAPIAPI_AbortDeployment_Call) Run(run func(ctx context.Context, deploymentId string)) *MockDeploymentsManagementAPIAPI_AbortDeployment_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 *MockDeploymentsManagementAPIAPI_AbortDeployment_Call) Return(apiAbortDeploymentRequest client.ApiAbortDeploymentRequest) *MockDeploymentsManagementAPIAPI_AbortDeployment_Call {
	_c.Call.Return(apiAbortDeploymentRequest)
	return _c
}

func (_c *MockDeploymentsManagementAPIAPI_AbortDeployment_Call) RunAndReturn(run func(ctx context.Context, deploymentId string) client.ApiAbortDeploymentRequest) *MockDeploymentsManagementAPIAPI_AbortDeployment_Call {
	_c.Call.Return(run)
	return _c
}

// AbortDeploymentExecute provides a mock function for the type MockDeploymentsManagementAPIAPI
func (_mock *MockDeploymentsManagementAPIAPI) AbortDeploymentExecute(r client.ApiAbortDeploymentRequest) (*http.Response, error) {
	ret := _mock.Called(r)

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

	var r0 *http.Response
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(client.ApiAbortDeploymentRequest) (*http.Response, error)); ok {
		return returnFunc(r)
	}
	if returnFunc, ok := ret.Get(0).(func(client.ApiAbortDeploymentRequest) *http.Response); ok {
		r0 = returnFunc(r)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*http.Response)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(client.ApiAbortDeploymentRequest) error); ok {
		r1 = returnFunc(r)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// AbortDeploymentExecute is a helper method to define mock.On call
//   - r client.ApiAbortDeploymentRequest
func (_e *MockDeploymentsManagementAPIAPI_Expecter) AbortDeploymentExecute(r interface{}) *MockDeploymentsManagementAPIAPI_AbortDeploymentExecute_Call {
	return &MockDeploymentsManagementAPIAPI_AbortDeploymentExecute_Call{Call: _e.mock.On("AbortDeploymentExecute", r)}
}

func (_c *MockDeploymentsManagementAPIAPI_AbortDeploymentExecute_Call) Run(run func(r client.ApiAbortDeploymentRequest)) *MockDeploymentsManagementAPIAPI_AbortDeploymentExecute_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 client.ApiAbortDeploymentRequest
		if args[0] != nil {
			arg0 = args[0].(client.ApiAbortDeploymentRequest)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *MockDeploymentsManagementAPIAPI_AbortDeploymentExecute_Call) Return(response *http.Response, err error) *MockDeploymentsManagementAPIAPI_AbortDeploymentExecute_Call {
	_c.Call.Return(response, err)
	return _c
}

func (_c *MockDeploymentsManagementAPIAPI_AbortDeploymentExecute_Call) RunAndReturn(run func(r client.ApiAbortDeploymentRequest) (*http.Response, error)) *MockDeploymentsManagementAPIAPI_AbortDeploymentExecute_Call {
	_c.Call.Return(run)
	return _c
}

// AbortDeploymentsForADevice provides a mock function for the type MockDeploymentsManagementAPIAPI
func (_mock *MockDeploymentsManagementAPIAPI) AbortDeploymentsForADevice(ctx context.Context, id string) client.ApiAbortDeploymentsForADeviceRequest {
	ret := _mock.Called(ctx, id)

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

	var r0 client.ApiAbortDeploymentsForADeviceRequest
	if returnFunc, ok := ret.Get(0).(func(context.Context, string) client.ApiAbortDeploymentsForADeviceRequest); ok {
		r0 = returnFunc(ctx, id)
	} else {
		r0 = ret.Get(0).(client.ApiAbortDeploymentsForADeviceRequest)
	}
	return r0
}

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

// AbortDeploymentsForADevice is a helper method to define mock.On call
//   - ctx context.Context
//   - id string
func (_e *MockDeploymentsManagementAPIAPI_Expecter) AbortDeploymentsForADevice(ctx interface{}, id interface{}) *MockDeploymentsManagementAPIAPI_AbortDeploymentsForADevice_Call {
	return &MockDeploymentsManagementAPIAPI_AbortDeploymentsForADevice_Call{Call: _e.mock.On("AbortDeploymentsForADevice", ctx, id)}
}

func (_c *MockDeploymentsManagementAPIAPI_AbortDeploymentsForADevice_Call) Run(run func(ctx context.Context, id string)) *MockDeploymentsManagementAPIAPI_AbortDeploymentsForADevice_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 *MockDeploymentsManagementAPIAPI_AbortDeploymentsForADevice_Call) Return(apiAbortDeploymentsForADeviceRequest client.ApiAbortDeploymentsForADeviceRequest) *MockDeploymentsManagementAPIAPI_AbortDeploymentsForADevice_Call {
	_c.Call.Return(apiAbortDeploymentsForADeviceRequest)
	return _c
}

func (_c *MockDeploymentsManagementAPIAPI_AbortDeploymentsForADevice_Call) RunAndReturn(run func(ctx context.Context, id string) client.ApiAbortDeploymentsForADeviceRequest) *MockDeploymentsManagementAPIAPI_AbortDeploymentsForADevice_Call {
	_c.Call.Return(run)
	return _c
}

// AbortDeploymentsForADeviceExecute provides a mock function for the type MockDeploymentsManagementAPIAPI
func (_mock *MockDeploymentsManagementAPIAPI) AbortDeploymentsForADeviceExecute(r client.ApiAbortDeploymentsForADeviceRequest) (*http.Response, error) {
	ret := _mock.Called(r)

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

	var r0 *http.Response
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(client.ApiAbortDeploymentsForADeviceRequest) (*http.Response, error)); ok {
		return returnFunc(r)
	}
	if returnFunc, ok := ret.Get(0).(func(client.ApiAbortDeploymentsForADeviceRequest) *http.Response); ok {
		r0 = returnFunc(r)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*http.Response)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(client.ApiAbortDeploymentsForADeviceRequest) error); ok {
		r1 = returnFunc(r)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// AbortDeploymentsForADeviceExecute is a helper method to define mock.On call
//   - r client.ApiAbortDeploymentsForADeviceRequest
func (_e *MockDeploymentsManagementAPIAPI_Expecter) AbortDeploymentsForADeviceExecute(r interface{}) *MockDeploymentsManagementAPIAPI_AbortDeploymentsForADeviceExecute_Call {
	return &MockDeploymentsManagementAPIAPI_AbortDeploymentsForADeviceExecute_Call{Call: _e.mock.On("AbortDeploymentsForADeviceExecute", r)}
}

func (_c *MockDeploymentsManagementAPIAPI_AbortDeploymentsForADeviceExecute_Call) Run(run func(r client.ApiAbortDeploymentsForADeviceRequest)) *MockDeploymentsManagementAPIAPI_AbortDeploymentsForADeviceExecute_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 client.ApiAbortDeploymentsForADeviceRequest
		if args[0] != nil {
			arg0 = args[0].(client.ApiAbortDeploymentsForADeviceRequest)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *MockDeploymentsManagementAPIAPI_AbortDeploymentsForADeviceExecute_Call) Return(response *http.Response, err error) *MockDeploymentsManagementAPIAPI_AbortDeploymentsForADeviceExecute_Call {
	_c.Call.Return(response, err)
	return _c
}

func (_c *MockDeploymentsManagementAPIAPI_AbortDeploymentsForADeviceExecute_Call) RunAndReturn(run func(r client.ApiAbortDeploymentsForADeviceRequest) (*http.Response, error)) *MockDeploymentsManagementAPIAPI_AbortDeploymentsForADeviceExecute_Call {
	_c.Call.Return(run)
	return _c
}

// CompleteDirectUpload provides a mock function for the type MockDeploymentsManagementAPIAPI
func (_mock *MockDeploymentsManagementAPIAPI) CompleteDirectUpload(ctx context.Context, id string) client.ApiCompleteDirectUploadRequest {
	ret := _mock.Called(ctx, id)

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

	var r0 client.ApiCompleteDirectUploadRequest
	if returnFunc, ok := ret.Get(0).(func(context.Context, string) client.ApiCompleteDirectUploadRequest); ok {
		r0 = returnFunc(ctx, id)
	} else {
		r0 = ret.Get(0).(client.ApiCompleteDirectUploadRequest)
	}
	return r0
}

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

// CompleteDirectUpload is a helper method to define mock.On call
//   - ctx context.Context
//   - id string
func (_e *MockDeploymentsManagementAPIAPI_Expecter) CompleteDirectUpload(ctx interface{}, id interface{}) *MockDeploymentsManagementAPIAPI_CompleteDirectUpload_Call {
	return &MockDeploymentsManagementAPIAPI_CompleteDirectUpload_Call{Call: _e.mock.On("CompleteDirectUpload", ctx, id)}
}

func (_c *MockDeploymentsManagementAPIAPI_CompleteDirectUpload_Call) Run(run func(ctx context.Context, id string)) *MockDeploymentsManagementAPIAPI_CompleteDirectUpload_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 *MockDeploymentsManagementAPIAPI_CompleteDirectUpload_Call) Return(apiCompleteDirectUploadRequest client.ApiCompleteDirectUploadRequest) *MockDeploymentsManagementAPIAPI_CompleteDirectUpload_Call {
	_c.Call.Return(apiCompleteDirectUploadRequest)
	return _c
}

func (_c *MockDeploymentsManagementAPIAPI_CompleteDirectUpload_Call) RunAndReturn(run func(ctx context.Context, id string) client.ApiCompleteDirectUploadRequest) *MockDeploymentsManagementAPIAPI_CompleteDirectUpload_Call {
	_c.Call.Return(run)
	return _c
}

// CompleteDirectUploadExecute provides a mock function for the type MockDeploymentsManagementAPIAPI
func (_mock *MockDeploymentsManagementAPIAPI) CompleteDirectUploadExecute(r client.ApiCompleteDirectUploadRequest) (*http.Response, error) {
	ret := _mock.Called(r)

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

	var r0 *http.Response
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(client.ApiCompleteDirectUploadRequest) (*http.Response, error)); ok {
		return returnFunc(r)
	}
	if returnFunc, ok := ret.Get(0).(func(client.ApiCompleteDirectUploadRequest) *http.Response); ok {
		r0 = returnFunc(r)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*http.Response)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(client.ApiCompleteDirectUploadRequest) error); ok {
		r1 = returnFunc(r)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// CompleteDirectUploadExecute is a helper method to define mock.On call
//   - r client.ApiCompleteDirectUploadRequest
func (_e *MockDeploymentsManagementAPIAPI_Expecter) CompleteDirectUploadExecute(r interface{}) *MockDeploymentsManagementAPIAPI_CompleteDirectUploadExecute_Call {
	return &MockDeploymentsManagementAPIAPI_CompleteDirectUploadExecute_Call{Call: _e.mock.On("CompleteDirectUploadExecute", r)}
}

func (_c *MockDeploymentsManagementAPIAPI_CompleteDirectUploadExecute_Call) Run(run func(r client.ApiCompleteDirectUploadRequest)) *MockDeploymentsManagementAPIAPI_CompleteDirectUploadExecute_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 client.ApiCompleteDirectUploadRequest
		if args[0] != nil {
			arg0 = args[0].(client.ApiCompleteDirectUploadRequest)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *MockDeploymentsManagementAPIAPI_CompleteDirectUploadExecute_Call) Return(response *http.Response, err error) *MockDeploymentsManagementAPIAPI_CompleteDirectUploadExecute_Call {
	_c.Call.Return(response, err)
	return _c
}

func (_c *MockDeploymentsManagementAPIAPI_CompleteDirectUploadExecute_Call) RunAndReturn(run func(r client.ApiCompleteDirectUploadRequest) (*http.Response, error)) *MockDeploymentsManagementAPIAPI_CompleteDirectUploadExecute_Call {
	_c.Call.Return(run)
	return _c
}

// CreateDeploymentForAGroupOfDevices provides a mock function for the type MockDeploymentsManagementAPIAPI
func (_mock *MockDeploymentsManagementAPIAPI) CreateDeploymentForAGroupOfDevices(ctx context.Context, name string) client.ApiCreateDeploymentForAGroupOfDevicesRequest {
	ret := _mock.Called(ctx, name)

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

	var r0 client.ApiCreateDeploymentForAGroupOfDevicesRequest
	if returnFunc, ok := ret.Get(0).(func(context.Context, string) client.ApiCreateDeploymentForAGroupOfDevicesRequest); ok {
		r0 = returnFunc(ctx, name)
	} else {
		r0 = ret.Get(0).(client.ApiCreateDeploymentForAGroupOfDevicesRequest)
	}
	return r0
}

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

// CreateDeploymentForAGroupOfDevices is a helper method to define mock.On call
//   - ctx context.Context
//   - name string
func (_e *MockDeploymentsManagementAPIAPI_Expecter) CreateDeploymentForAGroupOfDevices(ctx interface{}, name interface{}) *MockDeploymentsManagementAPIAPI_CreateDeploymentForAGroupOfDevices_Call {
	return &MockDeploymentsManagementAPIAPI_CreateDeploymentForAGroupOfDevices_Call{Call: _e.mock.On("CreateDeploymentForAGroupOfDevices", ctx, name)}
}

func (_c *MockDeploymentsManagementAPIAPI_CreateDeploymentForAGroupOfDevices_Call) Run(run func(ctx context.Context, name string)) *MockDeploymentsManagementAPIAPI_CreateDeploymentForAGroupOfDevices_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 *MockDeploymentsManagementAPIAPI_CreateDeploymentForAGroupOfDevices_Call) Return(apiCreateDeploymentForAGroupOfDevicesRequest client.ApiCreateDeploymentForAGroupOfDevicesRequest) *MockDeploymentsManagementAPIAPI_CreateDeploymentForAGroupOfDevices_Call {
	_c.Call.Return(apiCreateDeploymentForAGroupOfDevicesRequest)
	return _c
}

func (_c *MockDeploymentsManagementAPIAPI_CreateDeploymentForAGroupOfDevices_Call) RunAndReturn(run func(ctx context.Context, name string) client.ApiCreateDeploymentForAGroupOfDevicesRequest) *MockDeploymentsManagementAPIAPI_CreateDeploymentForAGroupOfDevices_Call {
	_c.Call.Return(run)
	return _c
}

// CreateDeploymentForAGroupOfDevicesExecute provides a mock function for the type MockDeploymentsManagementAPIAPI
func (_mock *MockDeploymentsManagementAPIAPI) CreateDeploymentForAGroupOfDevicesExecute(r client.ApiCreateDeploymentForAGroupOfDevicesRequest) (*http.Response, error) {
	ret := _mock.Called(r)

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

	var r0 *http.Response
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(client.ApiCreateDeploymentForAGroupOfDevicesRequest) (*http.Response, error)); ok {
		return returnFunc(r)
	}
	if returnFunc, ok := ret.Get(0).(func(client.ApiCreateDeploymentForAGroupOfDevicesRequest) *http.Response); ok {
		r0 = returnFunc(r)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*http.Response)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(client.ApiCreateDeploymentForAGroupOfDevicesRequest) error); ok {
		r1 = returnFunc(r)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// CreateDeploymentForAGroupOfDevicesExecute is a helper method to define mock.On call
//   - r client.ApiCreateDeploymentForAGroupOfDevicesRequest
func (_e *MockDeploymentsManagementAPIAPI_Expecter) CreateDeploymentForAGroupOfDevicesExecute(r interface{}) *MockDeploymentsManagementAPIAPI_CreateDeploymentForAGroupOfDevicesExecute_Call {
	return &MockDeploymentsManagementAPIAPI_CreateDeploymentForAGroupOfDevicesExecute_Call{Call: _e.mock.On("CreateDeploymentForAGroupOfDevicesExecute", r)}
}

func (_c *MockDeploymentsManagementAPIAPI_CreateDeploymentForAGroupOfDevicesExecute_Call) Run(run func(r client.ApiCreateDeploymentForAGroupOfDevicesRequest)) *MockDeploymentsManagementAPIAPI_CreateDeploymentForAGroupOfDevicesExecute_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 client.ApiCreateDeploymentForAGroupOfDevicesRequest
		if args[0] != nil {
			arg0 = args[0].(client.ApiCreateDeploymentForAGroupOfDevicesRequest)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *MockDeploymentsManagementAPIAPI_CreateDeploymentForAGroupOfDevicesExecute_Call) Return(response *http.Response, err error) *MockDeploymentsManagementAPIAPI_CreateDeploymentForAGroupOfDevicesExecute_Call {
	_c.Call.Return(response, err)
	return _c
}

func (_c *MockDeploymentsManagementAPIAPI_CreateDeploymentForAGroupOfDevicesExecute_Call) RunAndReturn(run func(r client.ApiCreateDeploymentForAGroupOfDevicesRequest) (*http.Response, error)) *MockDeploymentsManagementAPIAPI_CreateDeploymentForAGroupOfDevicesExecute_Call {
	_c.Call.Return(run)
	return _c
}

// DeleteArtifact provides a mock function for the type MockDeploymentsManagementAPIAPI
func (_mock *MockDeploymentsManagementAPIAPI) DeleteArtifact(ctx context.Context, id string) client.ApiDeleteArtifactRequest {
	ret := _mock.Called(ctx, id)

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

	var r0 client.ApiDeleteArtifactRequest
	if returnFunc, ok := ret.Get(0).(func(context.Context, string) client.ApiDeleteArtifactRequest); ok {
		r0 = returnFunc(ctx, id)
	} else {
		r0 = ret.Get(0).(client.ApiDeleteArtifactRequest)
	}
	return r0
}

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

// DeleteArtifact is a helper method to define mock.On call
//   - ctx context.Context
//   - id string
func (_e *MockDeploymentsManagementAPIAPI_Expecter) DeleteArtifact(ctx interface{}, id interface{}) *MockDeploymentsManagementAPIAPI_DeleteArtifact_Call {
	return &MockDeploymentsManagementAPIAPI_DeleteArtifact_Call{Call: _e.mock.On("DeleteArtifact", ctx, id)}
}

func (_c *MockDeploymentsManagementAPIAPI_DeleteArtifact_Call) Run(run func(ctx context.Context, id string)) *MockDeploymentsManagementAPIAPI_DeleteArtifact_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 *MockDeploymentsManagementAPIAPI_DeleteArtifact_Call) Return(apiDeleteArtifactRequest client.ApiDeleteArtifactRequest) *MockDeploymentsManagementAPIAPI_DeleteArtifact_Call {
	_c.Call.Return(apiDeleteArtifactRequest)
	return _c
}

func (_c *MockDeploymentsManagementAPIAPI_DeleteArtifact_Call) RunAndReturn(run func(ctx context.Context, id string) client.ApiDeleteArtifactRequest) *MockDeploymentsManagementAPIAPI_DeleteArtifact_Call {
	_c.Call.Return(run)
	return _c
}

// DeleteArtifactExecute provides a mock function for the type MockDeploymentsManagementAPIAPI
func (_mock *MockDeploymentsManagementAPIAPI) DeleteArtifactExecute(r client.ApiDeleteArtifactRequest) (*http.Response, error) {
	ret := _mock.Called(r)

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

	var r0 *http.Response
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(client.ApiDeleteArtifactRequest) (*http.Response, error)); ok {
		return returnFunc(r)
	}
	if returnFunc, ok := ret.Get(0).(func(client.ApiDeleteArtifactRequest) *http.Response); ok {
		r0 = returnFunc(r)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*http.Response)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(client.ApiDeleteArtifactRequest) error); ok {
		r1 = returnFunc(r)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// DeleteArtifactExecute is a helper method to define mock.On call
//   - r client.ApiDeleteArtifactRequest
func (_e *MockDeploymentsManagementAPIAPI_Expecter) DeleteArtifactExecute(r interface{}) *MockDeploymentsManagementAPIAPI_DeleteArtifactExecute_Call {
	return &MockDeploymentsManagementAPIAPI_DeleteArtifactExecute_Call{Call: _e.mock.On("DeleteArtifactExecute", r)}
}

func (_c *MockDeploymentsManagementAPIAPI_DeleteArtifactExecute_Call) Run(run func(r client.ApiDeleteArtifactRequest)) *MockDeploymentsManagementAPIAPI_DeleteArtifactExecute_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 client.ApiDeleteArtifactRequest
		if args[0] != nil {
			arg0 = args[0].(client.ApiDeleteArtifactRequest)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *MockDeploymentsManagementAPIAPI_DeleteArtifactExecute_Call) Return(response *http.Response, err error) *MockDeploymentsManagementAPIAPI_DeleteArtifactExecute_Call {
	_c.Call.Return(response, err)
	return _c
}

func (_c *MockDeploymentsManagementAPIAPI_DeleteArtifactExecute_Call) RunAndReturn(run func(r client.ApiDeleteArtifactRequest) (*http.Response, error)) *MockDeploymentsManagementAPIAPI_DeleteArtifactExecute_Call {
	_c.Call.Return(run)
	return _c
}

// DeploymentStatusStatistics provides a mock function for the type MockDeploymentsManagementAPIAPI
func (_mock *MockDeploymentsManagementAPIAPI) DeploymentStatusStatistics(ctx context.Context, deploymentId string) client.ApiDeploymentStatusStatisticsRequest {
	ret := _mock.Called(ctx, deploymentId)

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

	var r0 client.ApiDeploymentStatusStatisticsRequest
	if returnFunc, ok := ret.Get(0).(func(context.Context, string) client.ApiDeploymentStatusStatisticsRequest); ok {
		r0 = returnFunc(ctx, deploymentId)
	} else {
		r0 = ret.Get(0).(client.ApiDeploymentStatusStatisticsRequest)
	}
	return r0
}

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

// DeploymentStatusStatistics is a helper method to define mock.On call
//   - ctx context.Context
//   - deploymentId string
func (_e *MockDeploymentsManagementAPIAPI_Expecter) DeploymentStatusStatistics(ctx interface{}, deploymentId interface{}) *MockDeploymentsManagementAPIAPI_DeploymentStatusStatistics_Call {
	return &MockDeploymentsManagementAPIAPI_DeploymentStatusStatistics_Call{Call: _e.mock.On("DeploymentStatusStatistics", ctx, deploymentId)}
}

func (_c *MockDeploymentsManagementAPIAPI_DeploymentStatusStatistics_Call) Run(run func(ctx context.Context, deploymentId string)) *MockDeploymentsManagementAPIAPI_DeploymentStatusStatistics_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 *MockDeploymentsManagementAPIAPI_DeploymentStatusStatistics_Call) Return(apiDeploymentStatusStatisticsRequest client.ApiDeploymentStatusStatisticsRequest) *MockDeploymentsManagementAPIAPI_DeploymentStatusStatistics_Call {
	_c.Call.Return(apiDeploymentStatusStatisticsRequest)
	return _c
}

func (_c *MockDeploymentsManagementAPIAPI_DeploymentStatusStatistics_Call) RunAndReturn(run func(ctx context.Context, deploymentId string) client.ApiDeploymentStatusStatisticsRequest) *MockDeploymentsManagementAPIAPI_DeploymentStatusStatistics_Call {
	_c.Call.Return(run)
	return _c
}

// DeploymentStatusStatisticsExecute provides a mock function for the type MockDeploymentsManagementAPIAPI
func (_mock *MockDeploymentsManagementAPIAPI) DeploymentStatusStatisticsExecute(r client.ApiDeploymentStatusStatisticsRequest) (*client.Statistics, *http.Response, error) {
	ret := _mock.Called(r)

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

	var r0 *client.Statistics
	var r1 *http.Response
	var r2 error
	if returnFunc, ok := ret.Get(0).(func(client.ApiDeploymentStatusStatisticsRequest) (*client.Statistics, *http.Response, error)); ok {
		return returnFunc(r)
	}
	if returnFunc, ok := ret.Get(0).(func(client.ApiDeploymentStatusStatisticsRequest) *client.Statistics); ok {
		r0 = returnFunc(r)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*client.Statistics)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(client.ApiDeploymentStatusStatisticsRequest) *http.Response); ok {
		r1 = returnFunc(r)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*http.Response)
		}
	}
	if returnFunc, ok := ret.Get(2).(func(client.ApiDeploymentStatusStatisticsRequest) error); ok {
		r2 = returnFunc(r)
	} else {
		r2 = ret.Error(2)
	}
	return r0, r1, r2
}

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

// DeploymentStatusStatisticsExecute is a helper method to define mock.On call
//   - r client.ApiDeploymentStatusStatisticsRequest
func (_e *MockDeploymentsManagementAPIAPI_Expecter) DeploymentStatusStatisticsExecute(r interface{}) *MockDeploymentsManagementAPIAPI_DeploymentStatusStatisticsExecute_Call {
	return &MockDeploymentsManagementAPIAPI_DeploymentStatusStatisticsExecute_Call{Call: _e.mock.On("DeploymentStatusStatisticsExecute", r)}
}

func (_c *MockDeploymentsManagementAPIAPI_DeploymentStatusStatisticsExecute_Call) Run(run func(r client.ApiDeploymentStatusStatisticsRequest)) *MockDeploymentsManagementAPIAPI_DeploymentStatusStatisticsExecute_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 client.ApiDeploymentStatusStatisticsRequest
		if args[0] != nil {
			arg0 = args[0].(client.ApiDeploymentStatusStatisticsRequest)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *MockDeploymentsManagementAPIAPI_DeploymentStatusStatisticsExecute_Call) Return(statistics *client.Statistics, response *http.Response, err error) *MockDeploymentsManagementAPIAPI_DeploymentStatusStatisticsExecute_Call {
	_c.Call.Return(statistics, response, err)
	return _c
}

func (_c *MockDeploymentsManagementAPIAPI_DeploymentStatusStatisticsExecute_Call) RunAndReturn(run func(r client.ApiDeploymentStatusStatisticsRequest) (*client.Statistics, *http.Response, error)) *MockDeploymentsManagementAPIAPI_DeploymentStatusStatisticsExecute_Call {
	_c.Call.Return(run)
	return _c
}

// DeploymentStatusStatisticsList provides a mock function for the type MockDeploymentsManagementAPIAPI
func (_mock *MockDeploymentsManagementAPIAPI) DeploymentStatusStatisticsList(ctx context.Context) client.ApiDeploymentStatusStatisticsListRequest {
	ret := _mock.Called(ctx)

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

	var r0 client.ApiDeploymentStatusStatisticsListRequest
	if returnFunc, ok := ret.Get(0).(func(context.Context) client.ApiDeploymentStatusStatisticsListRequest); ok {
		r0 = returnFunc(ctx)
	} else {
		r0 = ret.Get(0).(client.ApiDeploymentStatusStatisticsListRequest)
	}
	return r0
}

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

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

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

func (_c *MockDeploymentsManagementAPIAPI_DeploymentStatusStatisticsList_Call) Return(apiDeploymentStatusStatisticsListRequest client.ApiDeploymentStatusStatisticsListRequest) *MockDeploymentsManagementAPIAPI_DeploymentStatusStatisticsList_Call {
	_c.Call.Return(apiDeploymentStatusStatisticsListRequest)
	return _c
}

func (_c *MockDeploymentsManagementAPIAPI_DeploymentStatusStatisticsList_Call) RunAndReturn(run func(ctx context.Context) client.ApiDeploymentStatusStatisticsListRequest) *MockDeploymentsManagementAPIAPI_DeploymentStatusStatisticsList_Call {
	_c.Call.Return(run)
	return _c
}

// DeploymentStatusStatisticsListExecute provides a mock function for the type MockDeploymentsManagementAPIAPI
func (_mock *MockDeploymentsManagementAPIAPI) DeploymentStatusStatisticsListExecute(r client.ApiDeploymentStatusStatisticsListRequest) ([]client.DeploymentStatusStatisticsList200ResponseInner, *http.Response, error) {
	ret := _mock.Called(r)

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

	var r0 []client.DeploymentStatusStatisticsList200ResponseInner
	var r1 *http.Response
	var r2 error
	if returnFunc, ok := ret.Get(0).(func(client.ApiDeploymentStatusStatisticsListRequest) ([]client.DeploymentStatusStatisticsList200ResponseInner, *http.Response, error)); ok {
		return returnFunc(r)
	}
	if returnFunc, ok := ret.Get(0).(func(client.ApiDeploymentStatusStatisticsListRequest) []client.DeploymentStatusStatisticsList200ResponseInner); ok {
		r0 = returnFunc(r)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]client.DeploymentStatusStatisticsList200ResponseInner)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(client.ApiDeploymentStatusStatisticsListRequest) *http.Response); ok {
		r1 = returnFunc(r)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*http.Response)
		}
	}
	if returnFunc, ok := ret.Get(2).(func(client.ApiDeploymentStatusStatisticsListRequest) error); ok {
		r2 = returnFunc(r)
	} else {
		r2 = ret.Error(2)
	}
	return r0, r1, r2
}

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

// DeploymentStatusStatisticsListExecute is a helper method to define mock.On call
//   - r client.ApiDeploymentStatusStatisticsListRequest
func (_e *MockDeploymentsManagementAPIAPI_Expecter) DeploymentStatusStatisticsListExecute(r interface{}) *MockDeploymentsManagementAPIAPI_DeploymentStatusStatisticsListExecute_Call {
	return &MockDeploymentsManagementAPIAPI_DeploymentStatusStatisticsListExecute_Call{Call: _e.mock.On("DeploymentStatusStatisticsListExecute", r)}
}

func (_c *MockDeploymentsManagementAPIAPI_DeploymentStatusStatisticsListExecute_Call) Run(run func(r client.ApiDeploymentStatusStatisticsListRequest)) *MockDeploymentsManagementAPIAPI_DeploymentStatusStatisticsListExecute_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 client.ApiDeploymentStatusStatisticsListRequest
		if args[0] != nil {
			arg0 = args[0].(client.ApiDeploymentStatusStatisticsListRequest)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *MockDeploymentsManagementAPIAPI_DeploymentStatusStatisticsListExecute_Call) Return(deploymentStatusStatisticsList200ResponseInners []client.DeploymentStatusStatisticsList200ResponseInner, response *http.Response, err error) *MockDeploymentsManagementAPIAPI_DeploymentStatusStatisticsListExecute_Call {
	_c.Call.Return(deploymentStatusStatisticsList200ResponseInners, response, err)
	return _c
}

func (_c *MockDeploymentsManagementAPIAPI_DeploymentStatusStatisticsListExecute_Call) RunAndReturn(run func(r client.ApiDeploymentStatusStatisticsListRequest) ([]client.DeploymentStatusStatisticsList200ResponseInner, *http.Response, error)) *MockDeploymentsManagementAPIAPI_DeploymentStatusStatisticsListExecute_Call {
	_c.Call.Return(run)
	return _c
}

// DeploymentsCreateDeployment provides a mock function for the type MockDeploymentsManagementAPIAPI
func (_mock *MockDeploymentsManagementAPIAPI) DeploymentsCreateDeployment(ctx context.Context) client.ApiDeploymentsCreateDeploymentRequest {
	ret := _mock.Called(ctx)

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

	var r0 client.ApiDeploymentsCreateDeploymentRequest
	if returnFunc, ok := ret.Get(0).(func(context.Context) client.ApiDeploymentsCreateDeploymentRequest); ok {
		r0 = returnFunc(ctx)
	} else {
		r0 = ret.Get(0).(client.ApiDeploymentsCreateDeploymentRequest)
	}
	return r0
}

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

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

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

func (_c *MockDeploymentsManagementAPIAPI_DeploymentsCreateDeployment_Call) Return(apiDeploymentsCreateDeploymentRequest client.ApiDeploymentsCreateDeploymentRequest) *MockDeploymentsManagementAPIAPI_DeploymentsCreateDeployment_Call {
	_c.Call.Return(apiDeploymentsCreateDeploymentRequest)
	return _c
}

func (_c *MockDeploymentsManagementAPIAPI_DeploymentsCreateDeployment_Call) RunAndReturn(run func(ctx context.Context) client.ApiDeploymentsCreateDeploymentRequest) *MockDeploymentsManagementAPIAPI_DeploymentsCreateDeployment_Call {
	_c.Call.Return(run)
	return _c
}

// DeploymentsCreateDeploymentExecute provides a mock function for the type MockDeploymentsManagementAPIAPI
func (_mock *MockDeploymentsManagementAPIAPI) DeploymentsCreateDeploymentExecute(r client.ApiDeploymentsCreateDeploymentRequest) (*http.Response, error) {
	ret := _mock.Called(r)

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

	var r0 *http.Response
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(client.ApiDeploymentsCreateDeploymentRequest) (*http.Response, error)); ok {
		return returnFunc(r)
	}
	if returnFunc, ok := ret.Get(0).(func(client.ApiDeploymentsCreateDeploymentRequest) *http.Response); ok {
		r0 = returnFunc(r)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*http.Response)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(client.ApiDeploymentsCreateDeploymentRequest) error); ok {
		r1 = returnFunc(r)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// DeploymentsCreateDeploymentExecute is a helper method to define mock.On call
//   - r client.ApiDeploymentsCreateDeploymentRequest
func (_e *MockDeploymentsManagementAPIAPI_Expecter) DeploymentsCreateDeploymentExecute(r interface{}) *MockDeploymentsManagementAPIAPI_DeploymentsCreateDeploymentExecute_Call {
	return &MockDeploymentsManagementAPIAPI_DeploymentsCreateDeploymentExecute_Call{Call: _e.mock.On("DeploymentsCreateDeploymentExecute", r)}
}

func (_c *MockDeploymentsManagementAPIAPI_DeploymentsCreateDeploymentExecute_Call) Run(run func(r client.ApiDeploymentsCreateDeploymentRequest)) *MockDeploymentsManagementAPIAPI_DeploymentsCreateDeploymentExecute_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 client.ApiDeploymentsCreateDeploymentRequest
		if args[0] != nil {
			arg0 = args[0].(client.ApiDeploymentsCreateDeploymentRequest)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *MockDeploymentsManagementAPIAPI_DeploymentsCreateDeploymentExecute_Call) Return(response *http.Response, err error) *MockDeploymentsManagementAPIAPI_DeploymentsCreateDeploymentExecute_Call {
	_c.Call.Return(response, err)
	return _c
}

func (_c *MockDeploymentsManagementAPIAPI_DeploymentsCreateDeploymentExecute_Call) RunAndReturn(run func(r client.ApiDeploymentsCreateDeploymentRequest) (*http.Response, error)) *MockDeploymentsManagementAPIAPI_DeploymentsCreateDeploymentExecute_Call {
	_c.Call.Return(run)
	return _c
}

// DeploymentsGetStorageUsage provides a mock function for the type MockDeploymentsManagementAPIAPI
func (_mock *MockDeploymentsManagementAPIAPI) DeploymentsGetStorageUsage(ctx context.Context) client.ApiDeploymentsGetStorageUsageRequest {
	ret := _mock.Called(ctx)

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

	var r0 client.ApiDeploymentsGetStorageUsageRequest
	if returnFunc, ok := ret.Get(0).(func(context.Context) client.ApiDeploymentsGetStorageUsageRequest); ok {
		r0 = returnFunc(ctx)
	} else {
		r0 = ret.Get(0).(client.ApiDeploymentsGetStorageUsageRequest)
	}
	return r0
}

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

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

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

func (_c *MockDeploymentsManagementAPIAPI_DeploymentsGetStorageUsage_Call) Return(apiDeploymentsGetStorageUsageRequest client.ApiDeploymentsGetStorageUsageRequest) *MockDeploymentsManagementAPIAPI_DeploymentsGetStorageUsage_Call {
	_c.Call.Return(apiDeploymentsGetStorageUsageRequest)
	return _c
}

func (_c *MockDeploymentsManagementAPIAPI_DeploymentsGetStorageUsage_Call) RunAndReturn(run func(ctx context.Context) client.ApiDeploymentsGetStorageUsageRequest) *MockDeploymentsManagementAPIAPI_DeploymentsGetStorageUsage_Call {
	_c.Call.Return(run)
	return _c
}

// DeploymentsGetStorageUsageExecute provides a mock function for the type MockDeploymentsManagementAPIAPI
func (_mock *MockDeploymentsManagementAPIAPI) DeploymentsGetStorageUsageExecute(r client.ApiDeploymentsGetStorageUsageRequest) (*client.StorageLimit, *http.Response, error) {
	ret := _mock.Called(r)

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

	var r0 *client.StorageLimit
	var r1 *http.Response
	var r2 error
	if returnFunc, ok := ret.Get(0).(func(client.ApiDeploymentsGetStorageUsageRequest) (*client.StorageLimit, *http.Response, error)); ok {
		return returnFunc(r)
	}
	if returnFunc, ok := ret.Get(0).(func(client.ApiDeploymentsGetStorageUsageRequest) *client.StorageLimit); ok {
		r0 = returnFunc(r)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*client.StorageLimit)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(client.ApiDeploymentsGetStorageUsageRequest) *http.Response); ok {
		r1 = returnFunc(r)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*http.Response)
		}
	}
	if returnFunc, ok := ret.Get(2).(func(client.ApiDeploymentsGetStorageUsageRequest) error); ok {
		r2 = returnFunc(r)
	} else {
		r2 = ret.Error(2)
	}
	return r0, r1, r2
}

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

// DeploymentsGetStorageUsageExecute is a helper method to define mock.On call
//   - r client.ApiDeploymentsGetStorageUsageRequest
func (_e *MockDeploymentsManagementAPIAPI_Expecter) DeploymentsGetStorageUsageExecute(r interface{}) *MockDeploymentsManagementAPIAPI_DeploymentsGetStorageUsageExecute_Call {
	return &MockDeploymentsManagementAPIAPI_DeploymentsGetStorageUsageExecute_Call{Call: _e.mock.On("DeploymentsGetStorageUsageExecute", r)}
}

func (_c *MockDeploymentsManagementAPIAPI_DeploymentsGetStorageUsageExecute_Call) Run(run func(r client.ApiDeploymentsGetStorageUsageRequest)) *MockDeploymentsManagementAPIAPI_DeploymentsGetStorageUsageExecute_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 client.ApiDeploymentsGetStorageUsageRequest
		if args[0] != nil {
			arg0 = args[0].(client.ApiDeploymentsGetStorageUsageRequest)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *MockDeploymentsManagementAPIAPI_DeploymentsGetStorageUsageExecute_Call) Return(storageLimit *client.StorageLimit, response *http.Response, err error) *MockDeploymentsManagementAPIAPI_DeploymentsGetStorageUsageExecute_Call {
	_c.Call.Return(storageLimit, response, err)
	return _c
}

func (_c *MockDeploymentsManagementAPIAPI_DeploymentsGetStorageUsageExecute_Call) RunAndReturn(run func(r client.ApiDeploymentsGetStorageUsageRequest) (*client.StorageLimit, *http.Response, error)) *MockDeploymentsManagementAPIAPI_DeploymentsGetStorageUsageExecute_Call {
	_c.Call.Return(run)
	return _c
}

// DeploymentsListDeploymentsForADevice provides a mock function for the type MockDeploymentsManagementAPIAPI
func (_mock *MockDeploymentsManagementAPIAPI) DeploymentsListDeploymentsForADevice(ctx context.Context, id string) client.ApiDeploymentsListDeploymentsForADeviceRequest {
	ret := _mock.Called(ctx, id)

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

	var r0 client.ApiDeploymentsListDeploymentsForADeviceRequest
	if returnFunc, ok := ret.Get(0).(func(context.Context, string) client.ApiDeploymentsListDeploymentsForADeviceRequest); ok {
		r0 = returnFunc(ctx, id)
	} else {
		r0 = ret.Get(0).(client.ApiDeploymentsListDeploymentsForADeviceRequest)
	}
	return r0
}

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

// DeploymentsListDeploymentsForADevice is a helper method to define mock.On call
//   - ctx context.Context
//   - id string
func (_e *MockDeploymentsManagementAPIAPI_Expecter) DeploymentsListDeploymentsForADevice(ctx interface{}, id interface{}) *MockDeploymentsManagementAPIAPI_DeploymentsListDeploymentsForADevice_Call {
	return &MockDeploymentsManagementAPIAPI_DeploymentsListDeploymentsForADevice_Call{Call: _e.mock.On("DeploymentsListDeploymentsForADevice", ctx, id)}
}

func (_c *MockDeploymentsManagementAPIAPI_DeploymentsListDeploymentsForADevice_Call) Run(run func(ctx context.Context, id string)) *MockDeploymentsManagementAPIAPI_DeploymentsListDeploymentsForADevice_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 *MockDeploymentsManagementAPIAPI_DeploymentsListDeploymentsForADevice_Call) Return(apiDeploymentsListDeploymentsForADeviceRequest client.ApiDeploymentsListDeploymentsForADeviceRequest) *MockDeploymentsManagementAPIAPI_DeploymentsListDeploymentsForADevice_Call {
	_c.Call.Return(apiDeploymentsListDeploymentsForADeviceRequest)
	return _c
}

func (_c *MockDeploymentsManagementAPIAPI_DeploymentsListDeploymentsForADevice_Call) RunAndReturn(run func(ctx context.Context, id string) client.ApiDeploymentsListDeploymentsForADeviceRequest) *MockDeploymentsManagementAPIAPI_DeploymentsListDeploymentsForADevice_Call {
	_c.Call.Return(run)
	return _c
}

// DeploymentsListDeploymentsForADeviceExecute provides a mock function for the type MockDeploymentsManagementAPIAPI
func (_mock *MockDeploymentsManagementAPIAPI) DeploymentsListDeploymentsForADeviceExecute(r client.ApiDeploymentsListDeploymentsForADeviceRequest) ([]client.DeviceDeploymentV1, *http.Response, error) {
	ret := _mock.Called(r)

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

	var r0 []client.DeviceDeploymentV1
	var r1 *http.Response
	var r2 error
	if returnFunc, ok := ret.Get(0).(func(client.ApiDeploymentsListDeploymentsForADeviceRequest) ([]client.DeviceDeploymentV1, *http.Response, error)); ok {
		return returnFunc(r)
	}
	if returnFunc, ok := ret.Get(0).(func(client.ApiDeploymentsListDeploymentsForADeviceRequest) []client.DeviceDeploymentV1); ok {
		r0 = returnFunc(r)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]client.DeviceDeploymentV1)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(client.ApiDeploymentsListDeploymentsForADeviceRequest) *http.Response); ok {
		r1 = returnFunc(r)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*http.Response)
		}
	}
	if returnFunc, ok := ret.Get(2).(func(client.ApiDeploymentsListDeploymentsForADeviceRequest) error); ok {
		r2 = returnFunc(r)
	} else {
		r2 = ret.Error(2)
	}
	return r0, r1, r2
}

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

// DeploymentsListDeploymentsForADeviceExecute is a helper method to define mock.On call
//   - r client.ApiDeploymentsListDeploymentsForADeviceRequest
func (_e *MockDeploymentsManagementAPIAPI_Expecter) DeploymentsListDeploymentsForADeviceExecute(r interface{}) *MockDeploymentsManagementAPIAPI_DeploymentsListDeploymentsForADeviceExecute_Call {
	return &MockDeploymentsManagementAPIAPI_DeploymentsListDeploymentsForADeviceExecute_Call{Call: _e.mock.On("DeploymentsListDeploymentsForADeviceExecute", r)}
}

func (_c *MockDeploymentsManagementAPIAPI_DeploymentsListDeploymentsForADeviceExecute_Call) Run(run func(r client.ApiDeploymentsListDeploymentsForADeviceRequest)) *MockDeploymentsManagementAPIAPI_DeploymentsListDeploymentsForADeviceExecute_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 client.ApiDeploymentsListDeploymentsForADeviceRequest
		if args[0] != nil {
			arg0 = args[0].(client.ApiDeploymentsListDeploymentsForADeviceRequest)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *MockDeploymentsManagementAPIAPI_DeploymentsListDeploymentsForADeviceExecute_Call) Return(deviceDeploymentV1s []client.DeviceDeploymentV1, response *http.Response, err error) *MockDeploymentsManagementAPIAPI_DeploymentsListDeploymentsForADeviceExecute_Call {
	_c.Call.Return(deviceDeploymentV1s, response, err)
	return _c
}

func (_c *MockDeploymentsManagementAPIAPI_DeploymentsListDeploymentsForADeviceExecute_Call) RunAndReturn(run func(r client.ApiDeploymentsListDeploymentsForADeviceRequest) ([]client.DeviceDeploymentV1, *http.Response, error)) *MockDeploymentsManagementAPIAPI_DeploymentsListDeploymentsForADeviceExecute_Call {
	_c.Call.Return(run)
	return _c
}

// DeploymentsV1ListArtifactsWithPagination provides a mock function for the type MockDeploymentsManagementAPIAPI
func (_mock *MockDeploymentsManagementAPIAPI) DeploymentsV1ListArtifactsWithPagination(ctx context.Context) client.ApiDeploymentsV1ListArtifactsWithPaginationRequest {
	ret := _mock.Called(ctx)

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

	var r0 client.ApiDeploymentsV1ListArtifactsWithPaginationRequest
	if returnFunc, ok := ret.Get(0).(func(context.Context) client.ApiDeploymentsV1ListArtifactsWithPaginationRequest); ok {
		r0 = returnFunc(ctx)
	} else {
		r0 = ret.Get(0).(client.ApiDeploymentsV1ListArtifactsWithPaginationRequest)
	}
	return r0
}

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

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

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

func (_c *MockDeploymentsManagementAPIAPI_DeploymentsV1ListArtifactsWithPagination_Call) Return(apiDeploymentsV1ListArtifactsWithPaginationRequest client.ApiDeploymentsV1ListArtifactsWithPaginationRequest) *MockDeploymentsManagementAPIAPI_DeploymentsV1ListArtifactsWithPagination_Call {
	_c.Call.Return(apiDeploymentsV1ListArtifactsWithPaginationRequest)
	return _c
}

func (_c *MockDeploymentsManagementAPIAPI_DeploymentsV1ListArtifactsWithPagination_Call) RunAndReturn(run func(ctx context.Context) client.ApiDeploymentsV1ListArtifactsWithPaginationRequest) *MockDeploymentsManagementAPIAPI_DeploymentsV1ListArtifactsWithPagination_Call {
	_c.Call.Return(run)
	return _c
}

// DeploymentsV1ListArtifactsWithPaginationExecute provides a mock function for the type MockDeploymentsManagementAPIAPI
func (_mock *MockDeploymentsManagementAPIAPI) DeploymentsV1ListArtifactsWithPaginationExecute(r client.ApiDeploymentsV1ListArtifactsWithPaginationRequest) ([]client.ArtifactV1, *http.Response, error) {
	ret := _mock.Called(r)

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

	var r0 []client.ArtifactV1
	var r1 *http.Response
	var r2 error
	if returnFunc, ok := ret.Get(0).(func(client.ApiDeploymentsV1ListArtifactsWithPaginationRequest) ([]client.ArtifactV1, *http.Response, error)); ok {
		return returnFunc(r)
	}
	if returnFunc, ok := ret.Get(0).(func(client.ApiDeploymentsV1ListArtifactsWithPaginationRequest) []client.ArtifactV1); ok {
		r0 = returnFunc(r)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]client.ArtifactV1)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(client.ApiDeploymentsV1ListArtifactsWithPaginationRequest) *http.Response); ok {
		r1 = returnFunc(r)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*http.Response)
		}
	}
	if returnFunc, ok := ret.Get(2).(func(client.ApiDeploymentsV1ListArtifactsWithPaginationRequest) error); ok {
		r2 = returnFunc(r)
	} else {
		r2 = ret.Error(2)
	}
	return r0, r1, r2
}

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

// DeploymentsV1ListArtifactsWithPaginationExecute is a helper method to define mock.On call
//   - r client.ApiDeploymentsV1ListArtifactsWithPaginationRequest
func (_e *MockDeploymentsManagementAPIAPI_Expecter) DeploymentsV1ListArtifactsWithPaginationExecute(r interface{}) *MockDeploymentsManagementAPIAPI_DeploymentsV1ListArtifactsWithPaginationExecute_Call {
	return &MockDeploymentsManagementAPIAPI_DeploymentsV1ListArtifactsWithPaginationExecute_Call{Call: _e.mock.On("DeploymentsV1ListArtifactsWithPaginationExecute", r)}
}

func (_c *MockDeploymentsManagementAPIAPI_DeploymentsV1ListArtifactsWithPaginationExecute_Call) Run(run func(r client.ApiDeploymentsV1ListArtifactsWithPaginationRequest)) *MockDeploymentsManagementAPIAPI_DeploymentsV1ListArtifactsWithPaginationExecute_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 client.ApiDeploymentsV1ListArtifactsWithPaginationRequest
		if args[0] != nil {
			arg0 = args[0].(client.ApiDeploymentsV1ListArtifactsWithPaginationRequest)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *MockDeploymentsManagementAPIAPI_DeploymentsV1ListArtifactsWithPaginationExecute_Call) Return(artifactV1s []client.ArtifactV1, response *http.Response, err error) *MockDeploymentsManagementAPIAPI_DeploymentsV1ListArtifactsWithPaginationExecute_Call {
	_c.Call.Return(artifactV1s, response, err)
	return _c
}

func (_c *MockDeploymentsManagementAPIAPI_DeploymentsV1ListArtifactsWithPaginationExecute_Call) RunAndReturn(run func(r client.ApiDeploymentsV1ListArtifactsWithPaginationRequest) ([]client.ArtifactV1, *http.Response, error)) *MockDeploymentsManagementAPIAPI_DeploymentsV1ListArtifactsWithPaginationExecute_Call {
	_c.Call.Return(run)
	return _c
}

// DeploymentsV1ListDeployments provides a mock function for the type MockDeploymentsManagementAPIAPI
func (_mock *MockDeploymentsManagementAPIAPI) DeploymentsV1ListDeployments(ctx context.Context) client.ApiDeploymentsV1ListDeploymentsRequest {
	ret := _mock.Called(ctx)

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

	var r0 client.ApiDeploymentsV1ListDeploymentsRequest
	if returnFunc, ok := ret.Get(0).(func(context.Context) client.ApiDeploymentsV1ListDeploymentsRequest); ok {
		r0 = returnFunc(ctx)
	} else {
		r0 = ret.Get(0).(client.ApiDeploymentsV1ListDeploymentsRequest)
	}
	return r0
}

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

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

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

func (_c *MockDeploymentsManagementAPIAPI_DeploymentsV1ListDeployments_Call) Return(apiDeploymentsV1ListDeploymentsRequest client.ApiDeploymentsV1ListDeploymentsRequest) *MockDeploymentsManagementAPIAPI_DeploymentsV1ListDeployments_Call {
	_c.Call.Return(apiDeploymentsV1ListDeploymentsRequest)
	return _c
}

func (_c *MockDeploymentsManagementAPIAPI_DeploymentsV1ListDeployments_Call) RunAndReturn(run func(ctx context.Context) client.ApiDeploymentsV1ListDeploymentsRequest) *MockDeploymentsManagementAPIAPI_DeploymentsV1ListDeployments_Call {
	_c.Call.Return(run)
	return _c
}

// DeploymentsV1ListDeploymentsExecute provides a mock function for the type MockDeploymentsManagementAPIAPI
func (_mock *MockDeploymentsManagementAPIAPI) DeploymentsV1ListDeploymentsExecute(r client.ApiDeploymentsV1ListDeploymentsRequest) ([]client.DeploymentV1, *http.Response, error) {
	ret := _mock.Called(r)

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

	var r0 []client.DeploymentV1
	var r1 *http.Response
	var r2 error
	if returnFunc, ok := ret.Get(0).(func(client.ApiDeploymentsV1ListDeploymentsRequest) ([]client.DeploymentV1, *http.Response, error)); ok {
		return returnFunc(r)
	}
	if returnFunc, ok := ret.Get(0).(func(client.ApiDeploymentsV1ListDeploymentsRequest) []client.DeploymentV1); ok {
		r0 = returnFunc(r)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]client.DeploymentV1)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(client.ApiDeploymentsV1ListDeploymentsRequest) *http.Response); ok {
		r1 = returnFunc(r)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*http.Response)
		}
	}
	if returnFunc, ok := ret.Get(2).(func(client.ApiDeploymentsV1ListDeploymentsRequest) error); ok {
		r2 = returnFunc(r)
	} else {
		r2 = ret.Error(2)
	}
	return r0, r1, r2
}

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

// DeploymentsV1ListDeploymentsExecute is a helper method to define mock.On call
//   - r client.ApiDeploymentsV1ListDeploymentsRequest
func (_e *MockDeploymentsManagementAPIAPI_Expecter) DeploymentsV1ListDeploymentsExecute(r interface{}) *MockDeploymentsManagementAPIAPI_DeploymentsV1ListDeploymentsExecute_Call {
	return &MockDeploymentsManagementAPIAPI_DeploymentsV1ListDeploymentsExecute_Call{Call: _e.mock.On("DeploymentsV1ListDeploymentsExecute", r)}
}

func (_c *MockDeploymentsManagementAPIAPI_DeploymentsV1ListDeploymentsExecute_Call) Run(run func(r client.ApiDeploymentsV1ListDeploymentsRequest)) *MockDeploymentsManagementAPIAPI_DeploymentsV1ListDeploymentsExecute_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 client.ApiDeploymentsV1ListDeploymentsRequest
		if args[0] != nil {
			arg0 = args[0].(client.ApiDeploymentsV1ListDeploymentsRequest)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *MockDeploymentsManagementAPIAPI_DeploymentsV1ListDeploymentsExecute_Call) Return(deploymentV1s []client.DeploymentV1, response *http.Response, err error) *MockDeploymentsManagementAPIAPI_DeploymentsV1ListDeploymentsExecute_Call {
	_c.Call.Return(deploymentV1s, response, err)
	return _c
}

func (_c *MockDeploymentsManagementAPIAPI_DeploymentsV1ListDeploymentsExecute_Call) RunAndReturn(run func(r client.ApiDeploymentsV1ListDeploymentsRequest) ([]client.DeploymentV1, *http.Response, error)) *MockDeploymentsManagementAPIAPI_DeploymentsV1ListDeploymentsExecute_Call {
	_c.Call.Return(run)
	return _c
}

// DeploymentsV1ListReleasesWithPagination provides a mock function for the type MockDeploymentsManagementAPIAPI
func (_mock *MockDeploymentsManagementAPIAPI) DeploymentsV1ListReleasesWithPagination(ctx context.Context) client.ApiDeploymentsV1ListReleasesWithPaginationRequest {
	ret := _mock.Called(ctx)

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

	var r0 client.ApiDeploymentsV1ListReleasesWithPaginationRequest
	if returnFunc, ok := ret.Get(0).(func(context.Context) client.ApiDeploymentsV1ListReleasesWithPaginationRequest); ok {
		r0 = returnFunc(ctx)
	} else {
		r0 = ret.Get(0).(client.ApiDeploymentsV1ListReleasesWithPaginationRequest)
	}
	return r0
}

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

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

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

func (_c *MockDeploymentsManagementAPIAPI_DeploymentsV1ListReleasesWithPagination_Call) Return(apiDeploymentsV1ListReleasesWithPaginationRequest client.ApiDeploymentsV1ListReleasesWithPaginationRequest) *MockDeploymentsManagementAPIAPI_DeploymentsV1ListReleasesWithPagination_Call {
	_c.Call.Return(apiDeploymentsV1ListReleasesWithPaginationRequest)
	return _c
}

func (_c *MockDeploymentsManagementAPIAPI_DeploymentsV1ListReleasesWithPagination_Call) RunAndReturn(run func(ctx context.Context) client.ApiDeploymentsV1ListReleasesWithPaginationRequest) *MockDeploymentsManagementAPIAPI_DeploymentsV1ListReleasesWithPagination_Call {
	_c.Call.Return(run)
	return _c
}

// DeploymentsV1ListReleasesWithPaginationExecute provides a mock function for the type MockDeploymentsManagementAPIAPI
func (_mock *MockDeploymentsManagementAPIAPI) DeploymentsV1ListReleasesWithPaginationExecute(r client.ApiDeploymentsV1ListReleasesWithPaginationRequest) ([]client.ReleaseV1, *http.Response, error) {
	ret := _mock.Called(r)

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

	var r0 []client.ReleaseV1
	var r1 *http.Response
	var r2 error
	if returnFunc, ok := ret.Get(0).(func(client.ApiDeploymentsV1ListReleasesWithPaginationRequest) ([]client.ReleaseV1, *http.Response, error)); ok {
		return returnFunc(r)
	}
	if returnFunc, ok := ret.Get(0).(func(client.ApiDeploymentsV1ListReleasesWithPaginationRequest) []client.ReleaseV1); ok {
		r0 = returnFunc(r)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]client.ReleaseV1)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(client.ApiDeploymentsV1ListReleasesWithPaginationRequest) *http.Response); ok {
		r1 = returnFunc(r)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*http.Response)
		}
	}
	if returnFunc, ok := ret.Get(2).(func(client.ApiDeploymentsV1ListReleasesWithPaginationRequest) error); ok {
		r2 = returnFunc(r)
	} else {
		r2 = ret.Error(2)
	}
	return r0, r1, r2
}

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

// DeploymentsV1ListReleasesWithPaginationExecute is a helper method to define mock.On call
//   - r client.ApiDeploymentsV1ListReleasesWithPaginationRequest
func (_e *MockDeploymentsManagementAPIAPI_Expecter) DeploymentsV1ListReleasesWithPaginationExecute(r interface{}) *MockDeploymentsManagementAPIAPI_DeploymentsV1ListReleasesWithPaginationExecute_Call {
	return &MockDeploymentsManagementAPIAPI_DeploymentsV1ListReleasesWithPaginationExecute_Call{Call: _e.mock.On("DeploymentsV1ListReleasesWithPaginationExecute", r)}
}

func (_c *MockDeploymentsManagementAPIAPI_DeploymentsV1ListReleasesWithPaginationExecute_Call) Run(run func(r client.ApiDeploymentsV1ListReleasesWithPaginationRequest)) *MockDeploymentsManagementAPIAPI_DeploymentsV1ListReleasesWithPaginationExecute_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 client.ApiDeploymentsV1ListReleasesWithPaginationRequest
		if args[0] != nil {
			arg0 = args[0].(client.ApiDeploymentsV1ListReleasesWithPaginationRequest)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *MockDeploymentsManagementAPIAPI_DeploymentsV1ListReleasesWithPaginationExecute_Call) Return(releaseV1s []client.ReleaseV1, response *http.Response, err error) *MockDeploymentsManagementAPIAPI_DeploymentsV1ListReleasesWithPaginationExecute_Call {
	_c.Call.Return(releaseV1s, response, err)
	return _c
}

func (_c *MockDeploymentsManagementAPIAPI_DeploymentsV1ListReleasesWithPaginationExecute_Call) RunAndReturn(run func(r client.ApiDeploymentsV1ListReleasesWithPaginationRequest) ([]client.ReleaseV1, *http.Response, error)) *MockDeploymentsManagementAPIAPI_DeploymentsV1ListReleasesWithPaginationExecute_Call {
	_c.Call.Return(run)
	return _c
}

// DownloadArtifact provides a mock function for the type MockDeploymentsManagementAPIAPI
func (_mock *MockDeploymentsManagementAPIAPI) DownloadArtifact(ctx context.Context, id string) client.ApiDownloadArtifactRequest {
	ret := _mock.Called(ctx, id)

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

	var r0 client.ApiDownloadArtifactRequest
	if returnFunc, ok := ret.Get(0).(func(context.Context, string) client.ApiDownloadArtifactRequest); ok {
		r0 = returnFunc(ctx, id)
	} else {
		r0 = ret.Get(0).(client.ApiDownloadArtifactRequest)
	}
	return r0
}

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

// DownloadArtifact is a helper method to define mock.On call
//   - ctx context.Context
//   - id string
func (_e *MockDeploymentsManagementAPIAPI_Expecter) DownloadArtifact(ctx interface{}, id interface{}) *MockDeploymentsManagementAPIAPI_DownloadArtifact_Call {
	return &MockDeploymentsManagementAPIAPI_DownloadArtifact_Call{Call: _e.mock.On("DownloadArtifact", ctx, id)}
}

func (_c *MockDeploymentsManagementAPIAPI_DownloadArtifact_Call) Run(run func(ctx context.Context, id string)) *MockDeploymentsManagementAPIAPI_DownloadArtifact_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 *MockDeploymentsManagementAPIAPI_DownloadArtifact_Call) Return(apiDownloadArtifactRequest client.ApiDownloadArtifactRequest) *MockDeploymentsManagementAPIAPI_DownloadArtifact_Call {
	_c.Call.Return(apiDownloadArtifactRequest)
	return _c
}

func (_c *MockDeploymentsManagementAPIAPI_DownloadArtifact_Call) RunAndReturn(run func(ctx context.Context, id string) client.ApiDownloadArtifactRequest) *MockDeploymentsManagementAPIAPI_DownloadArtifact_Call {
	_c.Call.Return(run)
	return _c
}

// DownloadArtifactExecute provides a mock function for the type MockDeploymentsManagementAPIAPI
func (_mock *MockDeploymentsManagementAPIAPI) DownloadArtifactExecute(r client.ApiDownloadArtifactRequest) (*client.ArtifactLink, *http.Response, error) {
	ret := _mock.Called(r)

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

	var r0 *client.ArtifactLink
	var r1 *http.Response
	var r2 error
	if returnFunc, ok := ret.Get(0).(func(client.ApiDownloadArtifactRequest) (*client.ArtifactLink, *http.Response, error)); ok {
		return returnFunc(r)
	}
	if returnFunc, ok := ret.Get(0).(func(client.ApiDownloadArtifactRequest) *client.ArtifactLink); ok {
		r0 = returnFunc(r)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*client.ArtifactLink)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(client.ApiDownloadArtifactRequest) *http.Response); ok {
		r1 = returnFunc(r)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*http.Response)
		}
	}
	if returnFunc, ok := ret.Get(2).(func(client.ApiDownloadArtifactRequest) error); ok {
		r2 = returnFunc(r)
	} else {
		r2 = ret.Error(2)
	}
	return r0, r1, r2
}

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

// DownloadArtifactExecute is a helper method to define mock.On call
//   - r client.ApiDownloadArtifactRequest
func (_e *MockDeploymentsManagementAPIAPI_Expecter) DownloadArtifactExecute(r interface{}) *MockDeploymentsManagementAPIAPI_DownloadArtifactExecute_Call {
	return &MockDeploymentsManagementAPIAPI_DownloadArtifactExecute_Call{Call: _e.mock.On("DownloadArtifactExecute", r)}
}

func (_c *MockDeploymentsManagementAPIAPI_DownloadArtifactExecute_Call) Run(run func(r client.ApiDownloadArtifactRequest)) *MockDeploymentsManagementAPIAPI_DownloadArtifactExecute_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 client.ApiDownloadArtifactRequest
		if args[0] != nil {
			arg0 = args[0].(client.ApiDownloadArtifactRequest)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *MockDeploymentsManagementAPIAPI_DownloadArtifactExecute_Call) Return(artifactLink *client.ArtifactLink, response *http.Response, err error) *MockDeploymentsManagementAPIAPI_DownloadArtifactExecute_Call {
	_c.Call.Return(artifactLink, response, err)
	return _c
}

func (_c *MockDeploymentsManagementAPIAPI_DownloadArtifactExecute_Call) RunAndReturn(run func(r client.ApiDownloadArtifactRequest) (*client.ArtifactLink, *http.Response, error)) *MockDeploymentsManagementAPIAPI_DownloadArtifactExecute_Call {
	_c.Call.Return(run)
	return _c
}

// GenerateArtifact provides a mock function for the type MockDeploymentsManagementAPIAPI
func (_mock *MockDeploymentsManagementAPIAPI) GenerateArtifact(ctx context.Context) client.ApiGenerateArtifactRequest {
	ret := _mock.Called(ctx)

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

	var r0 client.ApiGenerateArtifactRequest
	if returnFunc, ok := ret.Get(0).(func(context.Context) client.ApiGenerateArtifactRequest); ok {
		r0 = returnFunc(ctx)
	} else {
		r0 = ret.Get(0).(client.ApiGenerateArtifactRequest)
	}
	return r0
}

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

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

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

func (_c *MockDeploymentsManagementAPIAPI_GenerateArtifact_Call) Return(apiGenerateArtifactRequest client.ApiGenerateArtifactRequest) *MockDeploymentsManagementAPIAPI_GenerateArtifact_Call {
	_c.Call.Return(apiGenerateArtifactRequest)
	return _c
}

func (_c *MockDeploymentsManagementAPIAPI_GenerateArtifact_Call) RunAndReturn(run func(ctx context.Context) client.ApiGenerateArtifactRequest) *MockDeploymentsManagementAPIAPI_GenerateArtifact_Call {
	_c.Call.Return(run)
	return _c
}

// GenerateArtifactExecute provides a mock function for the type MockDeploymentsManagementAPIAPI
func (_mock *MockDeploymentsManagementAPIAPI) GenerateArtifactExecute(r client.ApiGenerateArtifactRequest) (*http.Response, error) {
	ret := _mock.Called(r)

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

	var r0 *http.Response
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(client.ApiGenerateArtifactRequest) (*http.Response, error)); ok {
		return returnFunc(r)
	}
	if returnFunc, ok := ret.Get(0).(func(client.ApiGenerateArtifactRequest) *http.Response); ok {
		r0 = returnFunc(r)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*http.Response)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(client.ApiGenerateArtifactRequest) error); ok {
		r1 = returnFunc(r)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// GenerateArtifactExecute is a helper method to define mock.On call
//   - r client.ApiGenerateArtifactRequest
func (_e *MockDeploymentsManagementAPIAPI_Expecter) GenerateArtifactExecute(r interface{}) *MockDeploymentsManagementAPIAPI_GenerateArtifactExecute_Call {
	return &MockDeploymentsManagementAPIAPI_GenerateArtifactExecute_Call{Call: _e.mock.On("GenerateArtifactExecute", r)}
}

func (_c *MockDeploymentsManagementAPIAPI_GenerateArtifactExecute_Call) Run(run func(r client.ApiGenerateArtifactRequest)) *MockDeploymentsManagementAPIAPI_GenerateArtifactExecute_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 client.ApiGenerateArtifactRequest
		if args[0] != nil {
			arg0 = args[0].(client.ApiGenerateArtifactRequest)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *MockDeploymentsManagementAPIAPI_GenerateArtifactExecute_Call) Return(response *http.Response, err error) *MockDeploymentsManagementAPIAPI_GenerateArtifactExecute_Call {
	_c.Call.Return(response, err)
	return _c
}

func (_c *MockDeploymentsManagementAPIAPI_GenerateArtifactExecute_Call) RunAndReturn(run func(r client.ApiGenerateArtifactRequest) (*http.Response, error)) *MockDeploymentsManagementAPIAPI_GenerateArtifactExecute_Call {
	_c.Call.Return(run)
	return _c
}

// GetDeploymentLogForDevice provides a mock function for the type MockDeploymentsManagementAPIAPI
func (_mock *MockDeploymentsManagementAPIAPI) GetDeploymentLogForDevice(ctx context.Context, deploymentId string, deviceId string) client.ApiGetDeploymentLogForDeviceRequest {
	ret := _mock.Called(ctx, deploymentId, deviceId)

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

	var r0 client.ApiGetDeploymentLogForDeviceRequest
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string) client.ApiGetDeploymentLogForDeviceRequest); ok {
		r0 = returnFunc(ctx, deploymentId, deviceId)
	} else {
		r0 = ret.Get(0).(client.ApiGetDeploymentLogForDeviceRequest)
	}
	return r0
}

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

// GetDeploymentLogForDevice is a helper method to define mock.On call
//   - ctx context.Context
//   - deploymentId string
//   - deviceId string
func (_e *MockDeploymentsManagementAPIAPI_Expecter) GetDeploymentLogForDevice(ctx interface{}, deploymentId interface{}, deviceId interface{}) *MockDeploymentsManagementAPIAPI_GetDeploymentLogForDevice_Call {
	return &MockDeploymentsManagementAPIAPI_GetDeploymentLogForDevice_Call{Call: _e.mock.On("GetDeploymentLogForDevice", ctx, deploymentId, deviceId)}
}

func (_c *MockDeploymentsManagementAPIAPI_GetDeploymentLogForDevice_Call) Run(run func(ctx context.Context, deploymentId string, deviceId string)) *MockDeploymentsManagementAPIAPI_GetDeploymentLogForDevice_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)
		}
		run(
			arg0,
			arg1,
			arg2,
		)
	})
	return _c
}

func (_c *MockDeploymentsManagementAPIAPI_GetDeploymentLogForDevice_Call) Return(apiGetDeploymentLogForDeviceRequest client.ApiGetDeploymentLogForDeviceRequest) *MockDeploymentsManagementAPIAPI_GetDeploymentLogForDevice_Call {
	_c.Call.Return(apiGetDeploymentLogForDeviceRequest)
	return _c
}

func (_c *MockDeploymentsManagementAPIAPI_GetDeploymentLogForDevice_Call) RunAndReturn(run func(ctx context.Context, deploymentId string, deviceId string) client.ApiGetDeploymentLogForDeviceRequest) *MockDeploymentsManagementAPIAPI_GetDeploymentLogForDevice_Call {
	_c.Call.Return(run)
	return _c
}

// GetDeploymentLogForDeviceExecute provides a mock function for the type MockDeploymentsManagementAPIAPI
func (_mock *MockDeploymentsManagementAPIAPI) GetDeploymentLogForDeviceExecute(r client.ApiGetDeploymentLogForDeviceRequest) (string, *http.Response, error) {
	ret := _mock.Called(r)

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

	var r0 string
	var r1 *http.Response
	var r2 error
	if returnFunc, ok := ret.Get(0).(func(client.ApiGetDeploymentLogForDeviceRequest) (string, *http.Response, error)); ok {
		return returnFunc(r)
	}
	if returnFunc, ok := ret.Get(0).(func(client.ApiGetDeploymentLogForDeviceRequest) string); ok {
		r0 = returnFunc(r)
	} else {
		r0 = ret.Get(0).(string)
	}
	if returnFunc, ok := ret.Get(1).(func(client.ApiGetDeploymentLogForDeviceRequest) *http.Response); ok {
		r1 = returnFunc(r)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*http.Response)
		}
	}
	if returnFunc, ok := ret.Get(2).(func(client.ApiGetDeploymentLogForDeviceRequest) error); ok {
		r2 = returnFunc(r)
	} else {
		r2 = ret.Error(2)
	}
	return r0, r1, r2
}

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

// GetDeploymentLogForDeviceExecute is a helper method to define mock.On call
//   - r client.ApiGetDeploymentLogForDeviceRequest
func (_e *MockDeploymentsManagementAPIAPI_Expecter) GetDeploymentLogForDeviceExecute(r interface{}) *MockDeploymentsManagementAPIAPI_GetDeploymentLogForDeviceExecute_Call {
	return &MockDeploymentsManagementAPIAPI_GetDeploymentLogForDeviceExecute_Call{Call: _e.mock.On("GetDeploymentLogForDeviceExecute", r)}
}

func (_c *MockDeploymentsManagementAPIAPI_GetDeploymentLogForDeviceExecute_Call) Run(run func(r client.ApiGetDeploymentLogForDeviceRequest)) *MockDeploymentsManagementAPIAPI_GetDeploymentLogForDeviceExecute_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 client.ApiGetDeploymentLogForDeviceRequest
		if args[0] != nil {
			arg0 = args[0].(client.ApiGetDeploymentLogForDeviceRequest)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *MockDeploymentsManagementAPIAPI_GetDeploymentLogForDeviceExecute_Call) Return(s string, response *http.Response, err error) *MockDeploymentsManagementAPIAPI_GetDeploymentLogForDeviceExecute_Call {
	_c.Call.Return(s, response, err)
	return _c
}

func (_c *MockDeploymentsManagementAPIAPI_GetDeploymentLogForDeviceExecute_Call) RunAndReturn(run func(r client.ApiGetDeploymentLogForDeviceRequest) (string, *http.Response, error)) *MockDeploymentsManagementAPIAPI_GetDeploymentLogForDeviceExecute_Call {
	_c.Call.Return(run)
	return _c
}

// ListAllDevicesInDeployment provides a mock function for the type MockDeploymentsManagementAPIAPI
func (_mock *MockDeploymentsManagementAPIAPI) ListAllDevicesInDeployment(ctx context.Context, deploymentId string) client.ApiListAllDevicesInDeploymentRequest {
	ret := _mock.Called(ctx, deploymentId)

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

	var r0 client.ApiListAllDevicesInDeploymentRequest
	if returnFunc, ok := ret.Get(0).(func(context.Context, string) client.ApiListAllDevicesInDeploymentRequest); ok {
		r0 = returnFunc(ctx, deploymentId)
	} else {
		r0 = ret.Get(0).(client.ApiListAllDevicesInDeploymentRequest)
	}
	return r0
}

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

// ListAllDevicesInDeployment is a helper method to define mock.On call
//   - ctx context.Context
//   - deploymentId string
func (_e *MockDeploymentsManagementAPIAPI_Expecter) ListAllDevicesInDeployment(ctx interface{}, deploymentId interface{}) *MockDeploymentsManagementAPIAPI_ListAllDevicesInDeployment_Call {
	return &MockDeploymentsManagementAPIAPI_ListAllDevicesInDeployment_Call{Call: _e.mock.On("ListAllDevicesInDeployment", ctx, deploymentId)}
}

func (_c *MockDeploymentsManagementAPIAPI_ListAllDevicesInDeployment_Call) Run(run func(ctx context.Context, deploymentId string)) *MockDeploymentsManagementAPIAPI_ListAllDevicesInDeployment_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 *MockDeploymentsManagementAPIAPI_ListAllDevicesInDeployment_Call) Return(apiListAllDevicesInDeploymentRequest client.ApiListAllDevicesInDeploymentRequest) *MockDeploymentsManagementAPIAPI_ListAllDevicesInDeployment_Call {
	_c.Call.Return(apiListAllDevicesInDeploymentRequest)
	return _c
}

func (_c *MockDeploymentsManagementAPIAPI_ListAllDevicesInDeployment_Call) RunAndReturn(run func(ctx context.Context, deploymentId string) client.ApiListAllDevicesInDeploymentRequest) *MockDeploymentsManagementAPIAPI_ListAllDevicesInDeployment_Call {
	_c.Call.Return(run)
	return _c
}

// ListAllDevicesInDeploymentExecute provides a mock function for the type MockDeploymentsManagementAPIAPI
func (_mock *MockDeploymentsManagementAPIAPI) ListAllDevicesInDeploymentExecute(r client.ApiListAllDevicesInDeploymentRequest) ([]client.DeviceWithImage, *http.Response, error) {
	ret := _mock.Called(r)

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

	var r0 []client.DeviceWithImage
	var r1 *http.Response
	var r2 error
	if returnFunc, ok := ret.Get(0).(func(client.ApiListAllDevicesInDeploymentRequest) ([]client.DeviceWithImage, *http.Response, error)); ok {
		return returnFunc(r)
	}
	if returnFunc, ok := ret.Get(0).(func(client.ApiListAllDevicesInDeploymentRequest) []client.DeviceWithImage); ok {
		r0 = returnFunc(r)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]client.DeviceWithImage)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(client.ApiListAllDevicesInDeploymentRequest) *http.Response); ok {
		r1 = returnFunc(r)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*http.Response)
		}
	}
	if returnFunc, ok := ret.Get(2).(func(client.ApiListAllDevicesInDeploymentRequest) error); ok {
		r2 = returnFunc(r)
	} else {
		r2 = ret.Error(2)
	}
	return r0, r1, r2
}

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

// ListAllDevicesInDeploymentExecute is a helper method to define mock.On call
//   - r client.ApiListAllDevicesInDeploymentRequest
func (_e *MockDeploymentsManagementAPIAPI_Expecter) ListAllDevicesInDeploymentExecute(r interface{}) *MockDeploymentsManagementAPIAPI_ListAllDevicesInDeploymentExecute_Call {
	return &MockDeploymentsManagementAPIAPI_ListAllDevicesInDeploymentExecute_Call{Call: _e.mock.On("ListAllDevicesInDeploymentExecute", r)}
}

func (_c *MockDeploymentsManagementAPIAPI_ListAllDevicesInDeploymentExecute_Call) Run(run func(r client.ApiListAllDevicesInDeploymentRequest)) *MockDeploymentsManagementAPIAPI_ListAllDevicesInDeploymentExecute_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 client.ApiListAllDevicesInDeploymentRequest
		if args[0] != nil {
			arg0 = args[0].(client.ApiListAllDevicesInDeploymentRequest)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *MockDeploymentsManagementAPIAPI_ListAllDevicesInDeploymentExecute_Call) Return(deviceWithImages []client.DeviceWithImage, response *http.Response, err error) *MockDeploymentsManagementAPIAPI_ListAllDevicesInDeploymentExecute_Call {
	_c.Call.Return(deviceWithImages, response, err)
	return _c
}

func (_c *MockDeploymentsManagementAPIAPI_ListAllDevicesInDeploymentExecute_Call) RunAndReturn(run func(r client.ApiListAllDevicesInDeploymentRequest) ([]client.DeviceWithImage, *http.Response, error)) *MockDeploymentsManagementAPIAPI_ListAllDevicesInDeploymentExecute_Call {
	_c.Call.Return(run)
	return _c
}

// ListArtifacts provides a mock function for the type MockDeploymentsManagementAPIAPI
func (_mock *MockDeploymentsManagementAPIAPI) ListArtifacts(ctx context.Context) client.ApiListArtifactsRequest {
	ret := _mock.Called(ctx)

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

	var r0 client.ApiListArtifactsRequest
	if returnFunc, ok := ret.Get(0).(func(context.Context) client.ApiListArtifactsRequest); ok {
		r0 = returnFunc(ctx)
	} else {
		r0 = ret.Get(0).(client.ApiListArtifactsRequest)
	}
	return r0
}

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

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

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

func (_c *MockDeploymentsManagementAPIAPI_ListArtifacts_Call) Return(apiListArtifactsRequest client.ApiListArtifactsRequest) *MockDeploymentsManagementAPIAPI_ListArtifacts_Call {
	_c.Call.Return(apiListArtifactsRequest)
	return _c
}

func (_c *MockDeploymentsManagementAPIAPI_ListArtifacts_Call) RunAndReturn(run func(ctx context.Context) client.ApiListArtifactsRequest) *MockDeploymentsManagementAPIAPI_ListArtifacts_Call {
	_c.Call.Return(run)
	return _c
}

// ListArtifactsExecute provides a mock function for the type MockDeploymentsManagementAPIAPI
func (_mock *MockDeploymentsManagementAPIAPI) ListArtifactsExecute(r client.ApiListArtifactsRequest) ([]client.ArtifactV1, *http.Response, error) {
	ret := _mock.Called(r)

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

	var r0 []client.ArtifactV1
	var r1 *http.Response
	var r2 error
	if returnFunc, ok := ret.Get(0).(func(client.ApiListArtifactsRequest) ([]client.ArtifactV1, *http.Response, error)); ok {
		return returnFunc(r)
	}
	if returnFunc, ok := ret.Get(0).(func(client.ApiListArtifactsRequest) []client.ArtifactV1); ok {
		r0 = returnFunc(r)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]client.ArtifactV1)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(client.ApiListArtifactsRequest) *http.Response); ok {
		r1 = returnFunc(r)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*http.Response)
		}
	}
	if returnFunc, ok := ret.Get(2).(func(client.ApiListArtifactsRequest) error); ok {
		r2 = returnFunc(r)
	} else {
		r2 = ret.Error(2)
	}
	return r0, r1, r2
}

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

// ListArtifactsExecute is a helper method to define mock.On call
//   - r client.ApiListArtifactsRequest
func (_e *MockDeploymentsManagementAPIAPI_Expecter) ListArtifactsExecute(r interface{}) *MockDeploymentsManagementAPIAPI_ListArtifactsExecute_Call {
	return &MockDeploymentsManagementAPIAPI_ListArtifactsExecute_Call{Call: _e.mock.On("ListArtifactsExecute", r)}
}

func (_c *MockDeploymentsManagementAPIAPI_ListArtifactsExecute_Call) Run(run func(r client.ApiListArtifactsRequest)) *MockDeploymentsManagementAPIAPI_ListArtifactsExecute_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 client.ApiListArtifactsRequest
		if args[0] != nil {
			arg0 = args[0].(client.ApiListArtifactsRequest)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *MockDeploymentsManagementAPIAPI_ListArtifactsExecute_Call) Return(artifactV1s []client.ArtifactV1, response *http.Response, err error) *MockDeploymentsManagementAPIAPI_ListArtifactsExecute_Call {
	_c.Call.Return(artifactV1s, response, err)
	return _c
}

func (_c *MockDeploymentsManagementAPIAPI_ListArtifactsExecute_Call) RunAndReturn(run func(r client.ApiListArtifactsRequest) ([]client.ArtifactV1, *http.Response, error)) *MockDeploymentsManagementAPIAPI_ListArtifactsExecute_Call {
	_c.Call.Return(run)
	return _c
}

// ListDeviceIDsInDeployment provides a mock function for the type MockDeploymentsManagementAPIAPI
func (_mock *MockDeploymentsManagementAPIAPI) ListDeviceIDsInDeployment(ctx context.Context, id string) client.ApiListDeviceIDsInDeploymentRequest {
	ret := _mock.Called(ctx, id)

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

	var r0 client.ApiListDeviceIDsInDeploymentRequest
	if returnFunc, ok := ret.Get(0).(func(context.Context, string) client.ApiListDeviceIDsInDeploymentRequest); ok {
		r0 = returnFunc(ctx, id)
	} else {
		r0 = ret.Get(0).(client.ApiListDeviceIDsInDeploymentRequest)
	}
	return r0
}

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

// ListDeviceIDsInDeployment is a helper method to define mock.On call
//   - ctx context.Context
//   - id string
func (_e *MockDeploymentsManagementAPIAPI_Expecter) ListDeviceIDsInDeployment(ctx interface{}, id interface{}) *MockDeploymentsManagementAPIAPI_ListDeviceIDsInDeployment_Call {
	return &MockDeploymentsManagementAPIAPI_ListDeviceIDsInDeployment_Call{Call: _e.mock.On("ListDeviceIDsInDeployment", ctx, id)}
}

func (_c *MockDeploymentsManagementAPIAPI_ListDeviceIDsInDeployment_Call) Run(run func(ctx context.Context, id string)) *MockDeploymentsManagementAPIAPI_ListDeviceIDsInDeployment_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 *MockDeploymentsManagementAPIAPI_ListDeviceIDsInDeployment_Call) Return(apiListDeviceIDsInDeploymentRequest client.ApiListDeviceIDsInDeploymentRequest) *MockDeploymentsManagementAPIAPI_ListDeviceIDsInDeployment_Call {
	_c.Call.Return(apiListDeviceIDsInDeploymentRequest)
	return _c
}

func (_c *MockDeploymentsManagementAPIAPI_ListDeviceIDsInDeployment_Call) RunAndReturn(run func(ctx context.Context, id string) client.ApiListDeviceIDsInDeploymentRequest) *MockDeploymentsManagementAPIAPI_ListDeviceIDsInDeployment_Call {
	_c.Call.Return(run)
	return _c
}

// ListDeviceIDsInDeploymentExecute provides a mock function for the type MockDeploymentsManagementAPIAPI
func (_mock *MockDeploymentsManagementAPIAPI) ListDeviceIDsInDeploymentExecute(r client.ApiListDeviceIDsInDeploymentRequest) ([]string, *http.Response, error) {
	ret := _mock.Called(r)

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

	var r0 []string
	var r1 *http.Response
	var r2 error
	if returnFunc, ok := ret.Get(0).(func(client.ApiListDeviceIDsInDeploymentRequest) ([]string, *http.Response, error)); ok {
		return returnFunc(r)
	}
	if returnFunc, ok := ret.Get(0).(func(client.ApiListDeviceIDsInDeploymentRequest) []string); ok {
		r0 = returnFunc(r)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]string)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(client.ApiListDeviceIDsInDeploymentRequest) *http.Response); ok {
		r1 = returnFunc(r)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*http.Response)
		}
	}
	if returnFunc, ok := ret.Get(2).(func(client.ApiListDeviceIDsInDeploymentRequest) error); ok {
		r2 = returnFunc(r)
	} else {
		r2 = ret.Error(2)
	}
	return r0, r1, r2
}

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

// ListDeviceIDsInDeploymentExecute is a helper method to define mock.On call
//   - r client.ApiListDeviceIDsInDeploymentRequest
func (_e *MockDeploymentsManagementAPIAPI_Expecter) ListDeviceIDsInDeploymentExecute(r interface{}) *MockDeploymentsManagementAPIAPI_ListDeviceIDsInDeploymentExecute_Call {
	return &MockDeploymentsManagementAPIAPI_ListDeviceIDsInDeploymentExecute_Call{Call: _e.mock.On("ListDeviceIDsInDeploymentExecute", r)}
}

func (_c *MockDeploymentsManagementAPIAPI_ListDeviceIDsInDeploymentExecute_Call) Run(run func(r client.ApiListDeviceIDsInDeploymentRequest)) *MockDeploymentsManagementAPIAPI_ListDeviceIDsInDeploymentExecute_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 client.ApiListDeviceIDsInDeploymentRequest
		if args[0] != nil {
			arg0 = args[0].(client.ApiListDeviceIDsInDeploymentRequest)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *MockDeploymentsManagementAPIAPI_ListDeviceIDsInDeploymentExecute_Call) Return(strings []string, response *http.Response, err error) *MockDeploymentsManagementAPIAPI_ListDeviceIDsInDeploymentExecute_Call {
	_c.Call.Return(strings, response, err)
	return _c
}

func (_c *MockDeploymentsManagementAPIAPI_ListDeviceIDsInDeploymentExecute_Call) RunAndReturn(run func(r client.ApiListDeviceIDsInDeploymentRequest) ([]string, *http.Response, error)) *MockDeploymentsManagementAPIAPI_ListDeviceIDsInDeploymentExecute_Call {
	_c.Call.Return(run)
	return _c
}

// ListDevicesInDeployment provides a mock function for the type MockDeploymentsManagementAPIAPI
func (_mock *MockDeploymentsManagementAPIAPI) ListDevicesInDeployment(ctx context.Context, deploymentId string) client.ApiListDevicesInDeploymentRequest {
	ret := _mock.Called(ctx, deploymentId)

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

	var r0 client.ApiListDevicesInDeploymentRequest
	if returnFunc, ok := ret.Get(0).(func(context.Context, string) client.ApiListDevicesInDeploymentRequest); ok {
		r0 = returnFunc(ctx, deploymentId)
	} else {
		r0 = ret.Get(0).(client.ApiListDevicesInDeploymentRequest)
	}
	return r0
}

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

// ListDevicesInDeployment is a helper method to define mock.On call
//   - ctx context.Context
//   - deploymentId string
func (_e *MockDeploymentsManagementAPIAPI_Expecter) ListDevicesInDeployment(ctx interface{}, deploymentId interface{}) *MockDeploymentsManagementAPIAPI_ListDevicesInDeployment_Call {
	return &MockDeploymentsManagementAPIAPI_ListDevicesInDeployment_Call{Call: _e.mock.On("ListDevicesInDeployment", ctx, deploymentId)}
}

func (_c *MockDeploymentsManagementAPIAPI_ListDevicesInDeployment_Call) Run(run func(ctx context.Context, deploymentId string)) *MockDeploymentsManagementAPIAPI_ListDevicesInDeployment_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 *MockDeploymentsManagementAPIAPI_ListDevicesInDeployment_Call) Return(apiListDevicesInDeploymentRequest client.ApiListDevicesInDeploymentRequest) *MockDeploymentsManagementAPIAPI_ListDevicesInDeployment_Call {
	_c.Call.Return(apiListDevicesInDeploymentRequest)
	return _c
}

func (_c *MockDeploymentsManagementAPIAPI_ListDevicesInDeployment_Call) RunAndReturn(run func(ctx context.Context, deploymentId string) client.ApiListDevicesInDeploymentRequest) *MockDeploymentsManagementAPIAPI_ListDevicesInDeployment_Call {
	_c.Call.Return(run)
	return _c
}

// ListDevicesInDeploymentExecute provides a mock function for the type MockDeploymentsManagementAPIAPI
func (_mock *MockDeploymentsManagementAPIAPI) ListDevicesInDeploymentExecute(r client.ApiListDevicesInDeploymentRequest) ([]client.DeviceWithImage, *http.Response, error) {
	ret := _mock.Called(r)

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

	var r0 []client.DeviceWithImage
	var r1 *http.Response
	var r2 error
	if returnFunc, ok := ret.Get(0).(func(client.ApiListDevicesInDeploymentRequest) ([]client.DeviceWithImage, *http.Response, error)); ok {
		return returnFunc(r)
	}
	if returnFunc, ok := ret.Get(0).(func(client.ApiListDevicesInDeploymentRequest) []client.DeviceWithImage); ok {
		r0 = returnFunc(r)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]client.DeviceWithImage)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(client.ApiListDevicesInDeploymentRequest) *http.Response); ok {
		r1 = returnFunc(r)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*http.Response)
		}
	}
	if returnFunc, ok := ret.Get(2).(func(client.ApiListDevicesInDeploymentRequest) error); ok {
		r2 = returnFunc(r)
	} else {
		r2 = ret.Error(2)
	}
	return r0, r1, r2
}

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

// ListDevicesInDeploymentExecute is a helper method to define mock.On call
//   - r client.ApiListDevicesInDeploymentRequest
func (_e *MockDeploymentsManagementAPIAPI_Expecter) ListDevicesInDeploymentExecute(r interface{}) *MockDeploymentsManagementAPIAPI_ListDevicesInDeploymentExecute_Call {
	return &MockDeploymentsManagementAPIAPI_ListDevicesInDeploymentExecute_Call{Call: _e.mock.On("ListDevicesInDeploymentExecute", r)}
}

func (_c *MockDeploymentsManagementAPIAPI_ListDevicesInDeploymentExecute_Call) Run(run func(r client.ApiListDevicesInDeploymentRequest)) *MockDeploymentsManagementAPIAPI_ListDevicesInDeploymentExecute_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 client.ApiListDevicesInDeploymentRequest
		if args[0] != nil {
			arg0 = args[0].(client.ApiListDevicesInDeploymentRequest)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *MockDeploymentsManagementAPIAPI_ListDevicesInDeploymentExecute_Call) Return(deviceWithImages []client.DeviceWithImage, response *http.Response, err error) *MockDeploymentsManagementAPIAPI_ListDevicesInDeploymentExecute_Call {
	_c.Call.Return(deviceWithImages, response, err)
	return _c
}

func (_c *MockDeploymentsManagementAPIAPI_ListDevicesInDeploymentExecute_Call) RunAndReturn(run func(r client.ApiListDevicesInDeploymentRequest) ([]client.DeviceWithImage, *http.Response, error)) *MockDeploymentsManagementAPIAPI_ListDevicesInDeploymentExecute_Call {
	_c.Call.Return(run)
	return _c
}

// ListReleases provides a mock function for the type MockDeploymentsManagementAPIAPI
func (_mock *MockDeploymentsManagementAPIAPI) ListReleases(ctx context.Context) client.ApiListReleasesRequest {
	ret := _mock.Called(ctx)

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

	var r0 client.ApiListReleasesRequest
	if returnFunc, ok := ret.Get(0).(func(context.Context) client.ApiListReleasesRequest); ok {
		r0 = returnFunc(ctx)
	} else {
		r0 = ret.Get(0).(client.ApiListReleasesRequest)
	}
	return r0
}

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

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

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

func (_c *MockDeploymentsManagementAPIAPI_ListReleases_Call) Return(apiListReleasesRequest client.ApiListReleasesRequest) *MockDeploymentsManagementAPIAPI_ListReleases_Call {
	_c.Call.Return(apiListReleasesRequest)
	return _c
}

func (_c *MockDeploymentsManagementAPIAPI_ListReleases_Call) RunAndReturn(run func(ctx context.Context) client.ApiListReleasesRequest) *MockDeploymentsManagementAPIAPI_ListReleases_Call {
	_c.Call.Return(run)
	return _c
}

// ListReleasesExecute provides a mock function for the type MockDeploymentsManagementAPIAPI
func (_mock *MockDeploymentsManagementAPIAPI) ListReleasesExecute(r client.ApiListReleasesRequest) ([]client.ReleaseV1, *http.Response, error) {
	ret := _mock.Called(r)

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

	var r0 []client.ReleaseV1
	var r1 *http.Response
	var r2 error
	if returnFunc, ok := ret.Get(0).(func(client.ApiListReleasesRequest) ([]client.ReleaseV1, *http.Response, error)); ok {
		return returnFunc(r)
	}
	if returnFunc, ok := ret.Get(0).(func(client.ApiListReleasesRequest) []client.ReleaseV1); ok {
		r0 = returnFunc(r)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]client.ReleaseV1)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(client.ApiListReleasesRequest) *http.Response); ok {
		r1 = returnFunc(r)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*http.Response)
		}
	}
	if returnFunc, ok := ret.Get(2).(func(client.ApiListReleasesRequest) error); ok {
		r2 = returnFunc(r)
	} else {
		r2 = ret.Error(2)
	}
	return r0, r1, r2
}

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

// ListReleasesExecute is a helper method to define mock.On call
//   - r client.ApiListReleasesRequest
func (_e *MockDeploymentsManagementAPIAPI_Expecter) ListReleasesExecute(r interface{}) *MockDeploymentsManagementAPIAPI_ListReleasesExecute_Call {
	return &MockDeploymentsManagementAPIAPI_ListReleasesExecute_Call{Call: _e.mock.On("ListReleasesExecute", r)}
}

func (_c *MockDeploymentsManagementAPIAPI_ListReleasesExecute_Call) Run(run func(r client.ApiListReleasesRequest)) *MockDeploymentsManagementAPIAPI_ListReleasesExecute_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 client.ApiListReleasesRequest
		if args[0] != nil {
			arg0 = args[0].(client.ApiListReleasesRequest)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *MockDeploymentsManagementAPIAPI_ListReleasesExecute_Call) Return(releaseV1s []client.ReleaseV1, response *http.Response, err error) *MockDeploymentsManagementAPIAPI_ListReleasesExecute_Call {
	_c.Call.Return(releaseV1s, response, err)
	return _c
}

func (_c *MockDeploymentsManagementAPIAPI_ListReleasesExecute_Call) RunAndReturn(run func(r client.ApiListReleasesRequest) ([]client.ReleaseV1, *http.Response, error)) *MockDeploymentsManagementAPIAPI_ListReleasesExecute_Call {
	_c.Call.Return(run)
	return _c
}

// RequestDirectUpload provides a mock function for the type MockDeploymentsManagementAPIAPI
func (_mock *MockDeploymentsManagementAPIAPI) RequestDirectUpload(ctx context.Context) client.ApiRequestDirectUploadRequest {
	ret := _mock.Called(ctx)

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

	var r0 client.ApiRequestDirectUploadRequest
	if returnFunc, ok := ret.Get(0).(func(context.Context) client.ApiRequestDirectUploadRequest); ok {
		r0 = returnFunc(ctx)
	} else {
		r0 = ret.Get(0).(client.ApiRequestDirectUploadRequest)
	}
	return r0
}

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

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

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

func (_c *MockDeploymentsManagementAPIAPI_RequestDirectUpload_Call) Return(apiRequestDirectUploadRequest client.ApiRequestDirectUploadRequest) *MockDeploymentsManagementAPIAPI_RequestDirectUpload_Call {
	_c.Call.Return(apiRequestDirectUploadRequest)
	return _c
}

func (_c *MockDeploymentsManagementAPIAPI_RequestDirectUpload_Call) RunAndReturn(run func(ctx context.Context) client.ApiRequestDirectUploadRequest) *MockDeploymentsManagementAPIAPI_RequestDirectUpload_Call {
	_c.Call.Return(run)
	return _c
}

// RequestDirectUploadExecute provides a mock function for the type MockDeploymentsManagementAPIAPI
func (_mock *MockDeploymentsManagementAPIAPI) RequestDirectUploadExecute(r client.ApiRequestDirectUploadRequest) (*client.ArtifactUploadLink, *http.Response, error) {
	ret := _mock.Called(r)

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

	var r0 *client.ArtifactUploadLink
	var r1 *http.Response
	var r2 error
	if returnFunc, ok := ret.Get(0).(func(client.ApiRequestDirectUploadRequest) (*client.ArtifactUploadLink, *http.Response, error)); ok {
		return returnFunc(r)
	}
	if returnFunc, ok := ret.Get(0).(func(client.ApiRequestDirectUploadRequest) *client.ArtifactUploadLink); ok {
		r0 = returnFunc(r)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*client.ArtifactUploadLink)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(client.ApiRequestDirectUploadRequest) *http.Response); ok {
		r1 = returnFunc(r)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*http.Response)
		}
	}
	if returnFunc, ok := ret.Get(2).(func(client.ApiRequestDirectUploadRequest) error); ok {
		r2 = returnFunc(r)
	} else {
		r2 = ret.Error(2)
	}
	return r0, r1, r2
}

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

// RequestDirectUploadExecute is a helper method to define mock.On call
//   - r client.ApiRequestDirectUploadRequest
func (_e *MockDeploymentsManagementAPIAPI_Expecter) RequestDirectUploadExecute(r interface{}) *MockDeploymentsManagementAPIAPI_RequestDirectUploadExecute_Call {
	return &MockDeploymentsManagementAPIAPI_RequestDirectUploadExecute_Call{Call: _e.mock.On("RequestDirectUploadExecute", r)}
}

func (_c *MockDeploymentsManagementAPIAPI_RequestDirectUploadExecute_Call) Run(run func(r client.ApiRequestDirectUploadRequest)) *MockDeploymentsManagementAPIAPI_RequestDirectUploadExecute_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 client.ApiRequestDirectUploadRequest
		if args[0] != nil {
			arg0 = args[0].(client.ApiRequestDirectUploadRequest)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *MockDeploymentsManagementAPIAPI_RequestDirectUploadExecute_Call) Return(artifactUploadLink *client.ArtifactUploadLink, response *http.Response, err error) *MockDeploymentsManagementAPIAPI_RequestDirectUploadExecute_Call {
	_c.Call.Return(artifactUploadLink, response, err)
	return _c
}

func (_c *MockDeploymentsManagementAPIAPI_RequestDirectUploadExecute_Call) RunAndReturn(run func(r client.ApiRequestDirectUploadRequest) (*client.ArtifactUploadLink, *http.Response, error)) *MockDeploymentsManagementAPIAPI_RequestDirectUploadExecute_Call {
	_c.Call.Return(run)
	return _c
}

// ResetDeviceDeploymentsHistory provides a mock function for the type MockDeploymentsManagementAPIAPI
func (_mock *MockDeploymentsManagementAPIAPI) ResetDeviceDeploymentsHistory(ctx context.Context, id string) client.ApiResetDeviceDeploymentsHistoryRequest {
	ret := _mock.Called(ctx, id)

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

	var r0 client.ApiResetDeviceDeploymentsHistoryRequest
	if returnFunc, ok := ret.Get(0).(func(context.Context, string) client.ApiResetDeviceDeploymentsHistoryRequest); ok {
		r0 = returnFunc(ctx, id)
	} else {
		r0 = ret.Get(0).(client.ApiResetDeviceDeploymentsHistoryRequest)
	}
	return r0
}

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

// ResetDeviceDeploymentsHistory is a helper method to define mock.On call
//   - ctx context.Context
//   - id string
func (_e *MockDeploymentsManagementAPIAPI_Expecter) ResetDeviceDeploymentsHistory(ctx interface{}, id interface{}) *MockDeploymentsManagementAPIAPI_ResetDeviceDeploymentsHistory_Call {
	return &MockDeploymentsManagementAPIAPI_ResetDeviceDeploymentsHistory_Call{Call: _e.mock.On("ResetDeviceDeploymentsHistory", ctx, id)}
}

func (_c *MockDeploymentsManagementAPIAPI_ResetDeviceDeploymentsHistory_Call) Run(run func(ctx context.Context, id string)) *MockDeploymentsManagementAPIAPI_ResetDeviceDeploymentsHistory_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 *MockDeploymentsManagementAPIAPI_ResetDeviceDeploymentsHistory_Call) Return(apiResetDeviceDeploymentsHistoryRequest client.ApiResetDeviceDeploymentsHistoryRequest) *MockDeploymentsManagementAPIAPI_ResetDeviceDeploymentsHistory_Call {
	_c.Call.Return(apiResetDeviceDeploymentsHistoryRequest)
	return _c
}

func (_c *MockDeploymentsManagementAPIAPI_ResetDeviceDeploymentsHistory_Call) RunAndReturn(run func(ctx context.Context, id string) client.ApiResetDeviceDeploymentsHistoryRequest) *MockDeploymentsManagementAPIAPI_ResetDeviceDeploymentsHistory_Call {
	_c.Call.Return(run)
	return _c
}

// ResetDeviceDeploymentsHistoryExecute provides a mock function for the type MockDeploymentsManagementAPIAPI
func (_mock *MockDeploymentsManagementAPIAPI) ResetDeviceDeploymentsHistoryExecute(r client.ApiResetDeviceDeploymentsHistoryRequest) (*http.Response, error) {
	ret := _mock.Called(r)

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

	var r0 *http.Response
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(client.ApiResetDeviceDeploymentsHistoryRequest) (*http.Response, error)); ok {
		return returnFunc(r)
	}
	if returnFunc, ok := ret.Get(0).(func(client.ApiResetDeviceDeploymentsHistoryRequest) *http.Response); ok {
		r0 = returnFunc(r)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*http.Response)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(client.ApiResetDeviceDeploymentsHistoryRequest) error); ok {
		r1 = returnFunc(r)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// ResetDeviceDeploymentsHistoryExecute is a helper method to define mock.On call
//   - r client.ApiResetDeviceDeploymentsHistoryRequest
func (_e *MockDeploymentsManagementAPIAPI_Expecter) ResetDeviceDeploymentsHistoryExecute(r interface{}) *MockDeploymentsManagementAPIAPI_ResetDeviceDeploymentsHistoryExecute_Call {
	return &MockDeploymentsManagementAPIAPI_ResetDeviceDeploymentsHistoryExecute_Call{Call: _e.mock.On("ResetDeviceDeploymentsHistoryExecute", r)}
}

func (_c *MockDeploymentsManagementAPIAPI_ResetDeviceDeploymentsHistoryExecute_Call) Run(run func(r client.ApiResetDeviceDeploymentsHistoryRequest)) *MockDeploymentsManagementAPIAPI_ResetDeviceDeploymentsHistoryExecute_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 client.ApiResetDeviceDeploymentsHistoryRequest
		if args[0] != nil {
			arg0 = args[0].(client.ApiResetDeviceDeploymentsHistoryRequest)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *MockDeploymentsManagementAPIAPI_ResetDeviceDeploymentsHistoryExecute_Call) Return(response *http.Response, err error) *MockDeploymentsManagementAPIAPI_ResetDeviceDeploymentsHistoryExecute_Call {
	_c.Call.Return(response, err)
	return _c
}

func (_c *MockDeploymentsManagementAPIAPI_ResetDeviceDeploymentsHistoryExecute_Call) RunAndReturn(run func(r client.ApiResetDeviceDeploymentsHistoryRequest) (*http.Response, error)) *MockDeploymentsManagementAPIAPI_ResetDeviceDeploymentsHistoryExecute_Call {
	_c.Call.Return(run)
	return _c
}

// ShowArtifact provides a mock function for the type MockDeploymentsManagementAPIAPI
func (_mock *MockDeploymentsManagementAPIAPI) ShowArtifact(ctx context.Context, id string) client.ApiShowArtifactRequest {
	ret := _mock.Called(ctx, id)

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

	var r0 client.ApiShowArtifactRequest
	if returnFunc, ok := ret.Get(0).(func(context.Context, string) client.ApiShowArtifactRequest); ok {
		r0 = returnFunc(ctx, id)
	} else {
		r0 = ret.Get(0).(client.ApiShowArtifactRequest)
	}
	return r0
}

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

// ShowArtifact is a helper method to define mock.On call
//   - ctx context.Context
//   - id string
func (_e *MockDeploymentsManagementAPIAPI_Expecter) ShowArtifact(ctx interface{}, id interface{}) *MockDeploymentsManagementAPIAPI_ShowArtifact_Call {
	return &MockDeploymentsManagementAPIAPI_ShowArtifact_Call{Call: _e.mock.On("ShowArtifact", ctx, id)}
}

func (_c *MockDeploymentsManagementAPIAPI_ShowArtifact_Call) Run(run func(ctx context.Context, id string)) *MockDeploymentsManagementAPIAPI_ShowArtifact_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 *MockDeploymentsManagementAPIAPI_ShowArtifact_Call) Return(apiShowArtifactRequest client.ApiShowArtifactRequest) *MockDeploymentsManagementAPIAPI_ShowArtifact_Call {
	_c.Call.Return(apiShowArtifactRequest)
	return _c
}

func (_c *MockDeploymentsManagementAPIAPI_ShowArtifact_Call) RunAndReturn(run func(ctx context.Context, id string) client.ApiShowArtifactRequest) *MockDeploymentsManagementAPIAPI_ShowArtifact_Call {
	_c.Call.Return(run)
	return _c
}

// ShowArtifactExecute provides a mock function for the type MockDeploymentsManagementAPIAPI
func (_mock *MockDeploymentsManagementAPIAPI) ShowArtifactExecute(r client.ApiShowArtifactRequest) (*client.ArtifactV1, *http.Response, error) {
	ret := _mock.Called(r)

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

	var r0 *client.ArtifactV1
	var r1 *http.Response
	var r2 error
	if returnFunc, ok := ret.Get(0).(func(client.ApiShowArtifactRequest) (*client.ArtifactV1, *http.Response, error)); ok {
		return returnFunc(r)
	}
	if returnFunc, ok := ret.Get(0).(func(client.ApiShowArtifactRequest) *client.ArtifactV1); ok {
		r0 = returnFunc(r)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*client.ArtifactV1)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(client.ApiShowArtifactRequest) *http.Response); ok {
		r1 = returnFunc(r)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*http.Response)
		}
	}
	if returnFunc, ok := ret.Get(2).(func(client.ApiShowArtifactRequest) error); ok {
		r2 = returnFunc(r)
	} else {
		r2 = ret.Error(2)
	}
	return r0, r1, r2
}

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

// ShowArtifactExecute is a helper method to define mock.On call
//   - r client.ApiShowArtifactRequest
func (_e *MockDeploymentsManagementAPIAPI_Expecter) ShowArtifactExecute(r interface{}) *MockDeploymentsManagementAPIAPI_ShowArtifactExecute_Call {
	return &MockDeploymentsManagementAPIAPI_ShowArtifactExecute_Call{Call: _e.mock.On("ShowArtifactExecute", r)}
}

func (_c *MockDeploymentsManagementAPIAPI_ShowArtifactExecute_Call) Run(run func(r client.ApiShowArtifactRequest)) *MockDeploymentsManagementAPIAPI_ShowArtifactExecute_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 client.ApiShowArtifactRequest
		if args[0] != nil {
			arg0 = args[0].(client.ApiShowArtifactRequest)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *MockDeploymentsManagementAPIAPI_ShowArtifactExecute_Call) Return(artifactV1 *client.ArtifactV1, response *http.Response, err error) *MockDeploymentsManagementAPIAPI_ShowArtifactExecute_Call {
	_c.Call.Return(artifactV1, response, err)
	return _c
}

func (_c *MockDeploymentsManagementAPIAPI_ShowArtifactExecute_Call) RunAndReturn(run func(r client.ApiShowArtifactRequest) (*client.ArtifactV1, *http.Response, error)) *MockDeploymentsManagementAPIAPI_ShowArtifactExecute_Call {
	_c.Call.Return(run)
	return _c
}

// ShowDeployment provides a mock function for the type MockDeploymentsManagementAPIAPI
func (_mock *MockDeploymentsManagementAPIAPI) ShowDeployment(ctx context.Context, id string) client.ApiShowDeploymentRequest {
	ret := _mock.Called(ctx, id)

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

	var r0 client.ApiShowDeploymentRequest
	if returnFunc, ok := ret.Get(0).(func(context.Context, string) client.ApiShowDeploymentRequest); ok {
		r0 = returnFunc(ctx, id)
	} else {
		r0 = ret.Get(0).(client.ApiShowDeploymentRequest)
	}
	return r0
}

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

// ShowDeployment is a helper method to define mock.On call
//   - ctx context.Context
//   - id string
func (_e *MockDeploymentsManagementAPIAPI_Expecter) ShowDeployment(ctx interface{}, id interface{}) *MockDeploymentsManagementAPIAPI_ShowDeployment_Call {
	return &MockDeploymentsManagementAPIAPI_ShowDeployment_Call{Call: _e.mock.On("ShowDeployment", ctx, id)}
}

func (_c *MockDeploymentsManagementAPIAPI_ShowDeployment_Call) Run(run func(ctx context.Context, id string)) *MockDeploymentsManagementAPIAPI_ShowDeployment_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 *MockDeploymentsManagementAPIAPI_ShowDeployment_Call) Return(apiShowDeploymentRequest client.ApiShowDeploymentRequest) *MockDeploymentsManagementAPIAPI_ShowDeployment_Call {
	_c.Call.Return(apiShowDeploymentRequest)
	return _c
}

func (_c *MockDeploymentsManagementAPIAPI_ShowDeployment_Call) RunAndReturn(run func(ctx context.Context, id string) client.ApiShowDeploymentRequest) *MockDeploymentsManagementAPIAPI_ShowDeployment_Call {
	_c.Call.Return(run)
	return _c
}

// ShowDeploymentExecute provides a mock function for the type MockDeploymentsManagementAPIAPI
func (_mock *MockDeploymentsManagementAPIAPI) ShowDeploymentExecute(r client.ApiShowDeploymentRequest) (*client.DeploymentV1, *http.Response, error) {
	ret := _mock.Called(r)

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

	var r0 *client.DeploymentV1
	var r1 *http.Response
	var r2 error
	if returnFunc, ok := ret.Get(0).(func(client.ApiShowDeploymentRequest) (*client.DeploymentV1, *http.Response, error)); ok {
		return returnFunc(r)
	}
	if returnFunc, ok := ret.Get(0).(func(client.ApiShowDeploymentRequest) *client.DeploymentV1); ok {
		r0 = returnFunc(r)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*client.DeploymentV1)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(client.ApiShowDeploymentRequest) *http.Response); ok {
		r1 = returnFunc(r)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*http.Response)
		}
	}
	if returnFunc, ok := ret.Get(2).(func(client.ApiShowDeploymentRequest) error); ok {
		r2 = returnFunc(r)
	} else {
		r2 = ret.Error(2)
	}
	return r0, r1, r2
}

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

// ShowDeploymentExecute is a helper method to define mock.On call
//   - r client.ApiShowDeploymentRequest
func (_e *MockDeploymentsManagementAPIAPI_Expecter) ShowDeploymentExecute(r interface{}) *MockDeploymentsManagementAPIAPI_ShowDeploymentExecute_Call {
	return &MockDeploymentsManagementAPIAPI_ShowDeploymentExecute_Call{Call: _e.mock.On("ShowDeploymentExecute", r)}
}

func (_c *MockDeploymentsManagementAPIAPI_ShowDeploymentExecute_Call) Run(run func(r client.ApiShowDeploymentRequest)) *MockDeploymentsManagementAPIAPI_ShowDeploymentExecute_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 client.ApiShowDeploymentRequest
		if args[0] != nil {
			arg0 = args[0].(client.ApiShowDeploymentRequest)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *MockDeploymentsManagementAPIAPI_ShowDeploymentExecute_Call) Return(deploymentV1 *client.DeploymentV1, response *http.Response, err error) *MockDeploymentsManagementAPIAPI_ShowDeploymentExecute_Call {
	_c.Call.Return(deploymentV1, response, err)
	return _c
}

func (_c *MockDeploymentsManagementAPIAPI_ShowDeploymentExecute_Call) RunAndReturn(run func(r client.ApiShowDeploymentRequest) (*client.DeploymentV1, *http.Response, error)) *MockDeploymentsManagementAPIAPI_ShowDeploymentExecute_Call {
	_c.Call.Return(run)
	return _c
}

// UpdateArtifactInfo provides a mock function for the type MockDeploymentsManagementAPIAPI
func (_mock *MockDeploymentsManagementAPIAPI) UpdateArtifactInfo(ctx context.Context, id string) client.ApiUpdateArtifactInfoRequest {
	ret := _mock.Called(ctx, id)

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

	var r0 client.ApiUpdateArtifactInfoRequest
	if returnFunc, ok := ret.Get(0).(func(context.Context, string) client.ApiUpdateArtifactInfoRequest); ok {
		r0 = returnFunc(ctx, id)
	} else {
		r0 = ret.Get(0).(client.ApiUpdateArtifactInfoRequest)
	}
	return r0
}

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

// UpdateArtifactInfo is a helper method to define mock.On call
//   - ctx context.Context
//   - id string
func (_e *MockDeploymentsManagementAPIAPI_Expecter) UpdateArtifactInfo(ctx interface{}, id interface{}) *MockDeploymentsManagementAPIAPI_UpdateArtifactInfo_Call {
	return &MockDeploymentsManagementAPIAPI_UpdateArtifactInfo_Call{Call: _e.mock.On("UpdateArtifactInfo", ctx, id)}
}

func (_c *MockDeploymentsManagementAPIAPI_UpdateArtifactInfo_Call) Run(run func(ctx context.Context, id string)) *MockDeploymentsManagementAPIAPI_UpdateArtifactInfo_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 *MockDeploymentsManagementAPIAPI_UpdateArtifactInfo_Call) Return(apiUpdateArtifactInfoRequest client.ApiUpdateArtifactInfoRequest) *MockDeploymentsManagementAPIAPI_UpdateArtifactInfo_Call {
	_c.Call.Return(apiUpdateArtifactInfoRequest)
	return _c
}

func (_c *MockDeploymentsManagementAPIAPI_UpdateArtifactInfo_Call) RunAndReturn(run func(ctx context.Context, id string) client.ApiUpdateArtifactInfoRequest) *MockDeploymentsManagementAPIAPI_UpdateArtifactInfo_Call {
	_c.Call.Return(run)
	return _c
}

// UpdateArtifactInfoExecute provides a mock function for the type MockDeploymentsManagementAPIAPI
func (_mock *MockDeploymentsManagementAPIAPI) UpdateArtifactInfoExecute(r client.ApiUpdateArtifactInfoRequest) (*http.Response, error) {
	ret := _mock.Called(r)

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

	var r0 *http.Response
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(client.ApiUpdateArtifactInfoRequest) (*http.Response, error)); ok {
		return returnFunc(r)
	}
	if returnFunc, ok := ret.Get(0).(func(client.ApiUpdateArtifactInfoRequest) *http.Response); ok {
		r0 = returnFunc(r)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*http.Response)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(client.ApiUpdateArtifactInfoRequest) error); ok {
		r1 = returnFunc(r)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// UpdateArtifactInfoExecute is a helper method to define mock.On call
//   - r client.ApiUpdateArtifactInfoRequest
func (_e *MockDeploymentsManagementAPIAPI_Expecter) UpdateArtifactInfoExecute(r interface{}) *MockDeploymentsManagementAPIAPI_UpdateArtifactInfoExecute_Call {
	return &MockDeploymentsManagementAPIAPI_UpdateArtifactInfoExecute_Call{Call: _e.mock.On("UpdateArtifactInfoExecute", r)}
}

func (_c *MockDeploymentsManagementAPIAPI_UpdateArtifactInfoExecute_Call) Run(run func(r client.ApiUpdateArtifactInfoRequest)) *MockDeploymentsManagementAPIAPI_UpdateArtifactInfoExecute_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 client.ApiUpdateArtifactInfoRequest
		if args[0] != nil {
			arg0 = args[0].(client.ApiUpdateArtifactInfoRequest)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *MockDeploymentsManagementAPIAPI_UpdateArtifactInfoExecute_Call) Return(response *http.Response, err error) *MockDeploymentsManagementAPIAPI_UpdateArtifactInfoExecute_Call {
	_c.Call.Return(response, err)
	return _c
}

func (_c *MockDeploymentsManagementAPIAPI_UpdateArtifactInfoExecute_Call) RunAndReturn(run func(r client.ApiUpdateArtifactInfoRequest) (*http.Response, error)) *MockDeploymentsManagementAPIAPI_UpdateArtifactInfoExecute_Call {
	_c.Call.Return(run)
	return _c
}

// UploadArtifact provides a mock function for the type MockDeploymentsManagementAPIAPI
func (_mock *MockDeploymentsManagementAPIAPI) UploadArtifact(ctx context.Context) client.ApiUploadArtifactRequest {
	ret := _mock.Called(ctx)

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

	var r0 client.ApiUploadArtifactRequest
	if returnFunc, ok := ret.Get(0).(func(context.Context) client.ApiUploadArtifactRequest); ok {
		r0 = returnFunc(ctx)
	} else {
		r0 = ret.Get(0).(client.ApiUploadArtifactRequest)
	}
	return r0
}

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

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

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

func (_c *MockDeploymentsManagementAPIAPI_UploadArtifact_Call) Return(apiUploadArtifactRequest client.ApiUploadArtifactRequest) *MockDeploymentsManagementAPIAPI_UploadArtifact_Call {
	_c.Call.Return(apiUploadArtifactRequest)
	return _c
}

func (_c *MockDeploymentsManagementAPIAPI_UploadArtifact_Call) RunAndReturn(run func(ctx context.Context) client.ApiUploadArtifactRequest) *MockDeploymentsManagementAPIAPI_UploadArtifact_Call {
	_c.Call.Return(run)
	return _c
}

// UploadArtifactExecute provides a mock function for the type MockDeploymentsManagementAPIAPI
func (_mock *MockDeploymentsManagementAPIAPI) UploadArtifactExecute(r client.ApiUploadArtifactRequest) (*http.Response, error) {
	ret := _mock.Called(r)

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

	var r0 *http.Response
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(client.ApiUploadArtifactRequest) (*http.Response, error)); ok {
		return returnFunc(r)
	}
	if returnFunc, ok := ret.Get(0).(func(client.ApiUploadArtifactRequest) *http.Response); ok {
		r0 = returnFunc(r)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*http.Response)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(client.ApiUploadArtifactRequest) error); ok {
		r1 = returnFunc(r)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// UploadArtifactExecute is a helper method to define mock.On call
//   - r client.ApiUploadArtifactRequest
func (_e *MockDeploymentsManagementAPIAPI_Expecter) UploadArtifactExecute(r interface{}) *MockDeploymentsManagementAPIAPI_UploadArtifactExecute_Call {
	return &MockDeploymentsManagementAPIAPI_UploadArtifactExecute_Call{Call: _e.mock.On("UploadArtifactExecute", r)}
}

func (_c *MockDeploymentsManagementAPIAPI_UploadArtifactExecute_Call) Run(run func(r client.ApiUploadArtifactRequest)) *MockDeploymentsManagementAPIAPI_UploadArtifactExecute_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 client.ApiUploadArtifactRequest
		if args[0] != nil {
			arg0 = args[0].(client.ApiUploadArtifactRequest)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *MockDeploymentsManagementAPIAPI_UploadArtifactExecute_Call) Return(response *http.Response, err error) *MockDeploymentsManagementAPIAPI_UploadArtifactExecute_Call {
	_c.Call.Return(response, err)
	return _c
}

func (_c *MockDeploymentsManagementAPIAPI_UploadArtifactExecute_Call) RunAndReturn(run func(r client.ApiUploadArtifactRequest) (*http.Response, error)) *MockDeploymentsManagementAPIAPI_UploadArtifactExecute_Call {
	_c.Call.Return(run)
	return _c
}

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

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

	return mock
}

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

type MockDeploymentsV1alpha1ManagementAPIAPI_Expecter struct {
	mock *mock.Mock
}

func (_m *MockDeploymentsV1alpha1ManagementAPIAPI) EXPECT() *MockDeploymentsV1alpha1ManagementAPIAPI_Expecter {
	return &MockDeploymentsV1alpha1ManagementAPIAPI_Expecter{mock: &_m.Mock}
}

// GetDeploymentSoftware provides a mock function for the type MockDeploymentsV1alpha1ManagementAPIAPI
func (_mock *MockDeploymentsV1alpha1ManagementAPIAPI) GetDeploymentSoftware(ctx context.Context) client.ApiGetDeploymentSoftwareRequest {
	ret := _mock.Called(ctx)

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

	var r0 client.ApiGetDeploymentSoftwareRequest
	if returnFunc, ok := ret.Get(0).(func(context.Context) client.ApiGetDeploymentSoftwareRequest); ok {
		r0 = returnFunc(ctx)
	} else {
		r0 = ret.Get(0).(client.ApiGetDeploymentSoftwareRequest)
	}
	return r0
}

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

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

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

func (_c *MockDeploymentsV1alpha1ManagementAPIAPI_GetDeploymentSoftware_Call) Return(apiGetDeploymentSoftwareRequest client.ApiGetDeploymentSoftwareRequest) *MockDeploymentsV1alpha1ManagementAPIAPI_GetDeploymentSoftware_Call {
	_c.Call.Return(apiGetDeploymentSoftwareRequest)
	return _c
}

func (_c *MockDeploymentsV1alpha1ManagementAPIAPI_GetDeploymentSoftware_Call) RunAndReturn(run func(ctx context.Context) client.ApiGetDeploymentSoftwareRequest) *MockDeploymentsV1alpha1ManagementAPIAPI_GetDeploymentSoftware_Call {
	_c.Call.Return(run)
	return _c
}

// GetDeploymentSoftwareExecute provides a mock function for the type MockDeploymentsV1alpha1ManagementAPIAPI
func (_mock *MockDeploymentsV1alpha1ManagementAPIAPI) GetDeploymentSoftwareExecute(r client.ApiGetDeploymentSoftwareRequest) ([]client.Software, *http.Response, error) {
	ret := _mock.Called(r)

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

	var r0 []client.Software
	var r1 *http.Response
	var r2 error
	if returnFunc, ok := ret.Get(0).(func(client.ApiGetDeploymentSoftwareRequest) ([]client.Software, *http.Response, error)); ok {
		return returnFunc(r)
	}
	if returnFunc, ok := ret.Get(0).(func(client.ApiGetDeploymentSoftwareRequest) []client.Software); ok {
		r0 = returnFunc(r)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]client.Software)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(client.ApiGetDeploymentSoftwareRequest) *http.Response); ok {
		r1 = returnFunc(r)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*http.Response)
		}
	}
	if returnFunc, ok := ret.Get(2).(func(client.ApiGetDeploymentSoftwareRequest) error); ok {
		r2 = returnFunc(r)
	} else {
		r2 = ret.Error(2)
	}
	return r0, r1, r2
}

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

// GetDeploymentSoftwareExecute is a helper method to define mock.On call
//   - r client.ApiGetDeploymentSoftwareRequest
func (_e *MockDeploymentsV1alpha1ManagementAPIAPI_Expecter) GetDeploymentSoftwareExecute(r interface{}) *MockDeploymentsV1alpha1ManagementAPIAPI_GetDeploymentSoftwareExecute_Call {
	return &MockDeploymentsV1alpha1ManagementAPIAPI_GetDeploymentSoftwareExecute_Call{Call: _e.mock.On("GetDeploymentSoftwareExecute", r)}
}

func (_c *MockDeploymentsV1alpha1ManagementAPIAPI_GetDeploymentSoftwareExecute_Call) Run(run func(r client.ApiGetDeploymentSoftwareRequest)) *MockDeploymentsV1alpha1ManagementAPIAPI_GetDeploymentSoftwareExecute_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 client.ApiGetDeploymentSoftwareRequest
		if args[0] != nil {
			arg0 = args[0].(client.ApiGetDeploymentSoftwareRequest)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *MockDeploymentsV1alpha1ManagementAPIAPI_GetDeploymentSoftwareExecute_Call) Return(softwares []client.Software, response *http.Response, err error) *MockDeploymentsV1alpha1ManagementAPIAPI_GetDeploymentSoftwareExecute_Call {
	_c.Call.Return(softwares, response, err)
	return _c
}

func (_c *MockDeploymentsV1alpha1ManagementAPIAPI_GetDeploymentSoftwareExecute_Call) RunAndReturn(run func(r client.ApiGetDeploymentSoftwareRequest) ([]client.Software, *http.Response, error)) *MockDeploymentsV1alpha1ManagementAPIAPI_GetDeploymentSoftwareExecute_Call {
	_c.Call.Return(run)
	return _c
}

// ListSoftwareTags provides a mock function for the type MockDeploymentsV1alpha1ManagementAPIAPI
func (_mock *MockDeploymentsV1alpha1ManagementAPIAPI) ListSoftwareTags(ctx context.Context) client.ApiListSoftwareTagsRequest {
	ret := _mock.Called(ctx)

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

	var r0 client.ApiListSoftwareTagsRequest
	if returnFunc, ok := ret.Get(0).(func(context.Context) client.ApiListSoftwareTagsRequest); ok {
		r0 = returnFunc(ctx)
	} else {
		r0 = ret.Get(0).(client.ApiListSoftwareTagsRequest)
	}
	return r0
}

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

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

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

func (_c *MockDeploymentsV1alpha1ManagementAPIAPI_ListSoftwareTags_Call) Return(apiListSoftwareTagsRequest client.ApiListSoftwareTagsRequest) *MockDeploymentsV1alpha1ManagementAPIAPI_ListSoftwareTags_Call {
	_c.Call.Return(apiListSoftwareTagsRequest)
	return _c
}

func (_c *MockDeploymentsV1alpha1ManagementAPIAPI_ListSoftwareTags_Call) RunAndReturn(run func(ctx context.Context) client.ApiListSoftwareTagsRequest) *MockDeploymentsV1alpha1ManagementAPIAPI_ListSoftwareTags_Call {
	_c.Call.Return(run)
	return _c
}

// ListSoftwareTagsExecute provides a mock function for the type MockDeploymentsV1alpha1ManagementAPIAPI
func (_mock *MockDeploymentsV1alpha1ManagementAPIAPI) ListSoftwareTagsExecute(r client.ApiListSoftwareTagsRequest) ([]string, *http.Response, error) {
	ret := _mock.Called(r)

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

	var r0 []string
	var r1 *http.Response
	var r2 error
	if returnFunc, ok := ret.Get(0).(func(client.ApiListSoftwareTagsRequest) ([]string, *http.Response, error)); ok {
		return returnFunc(r)
	}
	if returnFunc, ok := ret.Get(0).(func(client.ApiListSoftwareTagsRequest) []string); ok {
		r0 = returnFunc(r)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]string)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(client.ApiListSoftwareTagsRequest) *http.Response); ok {
		r1 = returnFunc(r)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*http.Response)
		}
	}
	if returnFunc, ok := ret.Get(2).(func(client.ApiListSoftwareTagsRequest) error); ok {
		r2 = returnFunc(r)
	} else {
		r2 = ret.Error(2)
	}
	return r0, r1, r2
}

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

// ListSoftwareTagsExecute is a helper method to define mock.On call
//   - r client.ApiListSoftwareTagsRequest
func (_e *MockDeploymentsV1alpha1ManagementAPIAPI_Expecter) ListSoftwareTagsExecute(r interface{}) *MockDeploymentsV1alpha1ManagementAPIAPI_ListSoftwareTagsExecute_Call {
	return &MockDeploymentsV1alpha1ManagementAPIAPI_ListSoftwareTagsExecute_Call{Call: _e.mock.On("ListSoftwareTagsExecute", r)}
}

func (_c *MockDeploymentsV1alpha1ManagementAPIAPI_ListSoftwareTagsExecute_Call) Run(run func(r client.ApiListSoftwareTagsRequest)) *MockDeploymentsV1alpha1ManagementAPIAPI_ListSoftwareTagsExecute_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 client.ApiListSoftwareTagsRequest
		if args[0] != nil {
			arg0 = args[0].(client.ApiListSoftwareTagsRequest)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *MockDeploymentsV1alpha1ManagementAPIAPI_ListSoftwareTagsExecute_Call) Return(strings []string, response *http.Response, err error) *MockDeploymentsV1alpha1ManagementAPIAPI_ListSoftwareTagsExecute_Call {
	_c.Call.Return(strings, response, err)
	return _c
}

func (_c *MockDeploymentsV1alpha1ManagementAPIAPI_ListSoftwareTagsExecute_Call) RunAndReturn(run func(r client.ApiListSoftwareTagsRequest) ([]string, *http.Response, error)) *MockDeploymentsV1alpha1ManagementAPIAPI_ListSoftwareTagsExecute_Call {
	_c.Call.Return(run)
	return _c
}

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

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

	return mock
}

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

type MockDeploymentsV2ManagementAPIAPI_Expecter struct {
	mock *mock.Mock
}

func (_m *MockDeploymentsV2ManagementAPIAPI) EXPECT() *MockDeploymentsV2ManagementAPIAPI_Expecter {
	return &MockDeploymentsV2ManagementAPIAPI_Expecter{mock: &_m.Mock}
}

// AssignReleaseTags provides a mock function for the type MockDeploymentsV2ManagementAPIAPI
func (_mock *MockDeploymentsV2ManagementAPIAPI) AssignReleaseTags(ctx context.Context, releaseName string) client.ApiAssignReleaseTagsRequest {
	ret := _mock.Called(ctx, releaseName)

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

	var r0 client.ApiAssignReleaseTagsRequest
	if returnFunc, ok := ret.Get(0).(func(context.Context, string) client.ApiAssignReleaseTagsRequest); ok {
		r0 = returnFunc(ctx, releaseName)
	} else {
		r0 = ret.Get(0).(client.ApiAssignReleaseTagsRequest)
	}
	return r0
}

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

// AssignReleaseTags is a helper method to define mock.On call
//   - ctx context.Context
//   - releaseName string
func (_e *MockDeploymentsV2ManagementAPIAPI_Expecter) AssignReleaseTags(ctx interface{}, releaseName interface{}) *MockDeploymentsV2ManagementAPIAPI_AssignReleaseTags_Call {
	return &MockDeploymentsV2ManagementAPIAPI_AssignReleaseTags_Call{Call: _e.mock.On("AssignReleaseTags", ctx, releaseName)}
}

func (_c *MockDeploymentsV2ManagementAPIAPI_AssignReleaseTags_Call) Run(run func(ctx context.Context, releaseName string)) *MockDeploymentsV2ManagementAPIAPI_AssignReleaseTags_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 *MockDeploymentsV2ManagementAPIAPI_AssignReleaseTags_Call) Return(apiAssignReleaseTagsRequest client.ApiAssignReleaseTagsRequest) *MockDeploymentsV2ManagementAPIAPI_AssignReleaseTags_Call {
	_c.Call.Return(apiAssignReleaseTagsRequest)
	return _c
}

func (_c *MockDeploymentsV2ManagementAPIAPI_AssignReleaseTags_Call) RunAndReturn(run func(ctx context.Context, releaseName string) client.ApiAssignReleaseTagsRequest) *MockDeploymentsV2ManagementAPIAPI_AssignReleaseTags_Call {
	_c.Call.Return(run)
	return _c
}

// AssignReleaseTagsExecute provides a mock function for the type MockDeploymentsV2ManagementAPIAPI
func (_mock *MockDeploymentsV2ManagementAPIAPI) AssignReleaseTagsExecute(r client.ApiAssignReleaseTagsRequest) (*http.Response, error) {
	ret := _mock.Called(r)

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

	var r0 *http.Response
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(client.ApiAssignReleaseTagsRequest) (*http.Response, error)); ok {
		return returnFunc(r)
	}
	if returnFunc, ok := ret.Get(0).(func(client.ApiAssignReleaseTagsRequest) *http.Response); ok {
		r0 = returnFunc(r)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*http.Response)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(client.ApiAssignReleaseTagsRequest) error); ok {
		r1 = returnFunc(r)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// AssignReleaseTagsExecute is a helper method to define mock.On call
//   - r client.ApiAssignReleaseTagsRequest
func (_e *MockDeploymentsV2ManagementAPIAPI_Expecter) AssignReleaseTagsExecute(r interface{}) *MockDeploymentsV2ManagementAPIAPI_AssignReleaseTagsExecute_Call {
	return &MockDeploymentsV2ManagementAPIAPI_AssignReleaseTagsExecute_Call{Call: _e.mock.On("AssignReleaseTagsExecute", r)}
}

func (_c *MockDeploymentsV2ManagementAPIAPI_AssignReleaseTagsExecute_Call) Run(run func(r client.ApiAssignReleaseTagsRequest)) *MockDeploymentsV2ManagementAPIAPI_AssignReleaseTagsExecute_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 client.ApiAssignReleaseTagsRequest
		if args[0] != nil {
			arg0 = args[0].(client.ApiAssignReleaseTagsRequest)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *MockDeploymentsV2ManagementAPIAPI_AssignReleaseTagsExecute_Call) Return(response *http.Response, err error) *MockDeploymentsV2ManagementAPIAPI_AssignReleaseTagsExecute_Call {
	_c.Call.Return(response, err)
	return _c
}

func (_c *MockDeploymentsV2ManagementAPIAPI_AssignReleaseTagsExecute_Call) RunAndReturn(run func(r client.ApiAssignReleaseTagsRequest) (*http.Response, error)) *MockDeploymentsV2ManagementAPIAPI_AssignReleaseTagsExecute_Call {
	_c.Call.Return(run)
	return _c
}

// DeleteReleases provides a mock function for the type MockDeploymentsV2ManagementAPIAPI
func (_mock *MockDeploymentsV2ManagementAPIAPI) DeleteReleases(ctx context.Context) client.ApiDeleteReleasesRequest {
	ret := _mock.Called(ctx)

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

	var r0 client.ApiDeleteReleasesRequest
	if returnFunc, ok := ret.Get(0).(func(context.Context) client.ApiDeleteReleasesRequest); ok {
		r0 = returnFunc(ctx)
	} else {
		r0 = ret.Get(0).(client.ApiDeleteReleasesRequest)
	}
	return r0
}

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

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

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

func (_c *MockDeploymentsV2ManagementAPIAPI_DeleteReleases_Call) Return(apiDeleteReleasesRequest client.ApiDeleteReleasesRequest) *MockDeploymentsV2ManagementAPIAPI_DeleteReleases_Call {
	_c.Call.Return(apiDeleteReleasesRequest)
	return _c
}

func (_c *MockDeploymentsV2ManagementAPIAPI_DeleteReleases_Call) RunAndReturn(run func(ctx context.Context) client.ApiDeleteReleasesRequest) *MockDeploymentsV2ManagementAPIAPI_DeleteReleases_Call {
	_c.Call.Return(run)
	return _c
}

// DeleteReleasesExecute provides a mock function for the type MockDeploymentsV2ManagementAPIAPI
func (_mock *MockDeploymentsV2ManagementAPIAPI) DeleteReleasesExecute(r client.ApiDeleteReleasesRequest) (*http.Response, error) {
	ret := _mock.Called(r)

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

	var r0 *http.Response
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(client.ApiDeleteReleasesRequest) (*http.Response, error)); ok {
		return returnFunc(r)
	}
	if returnFunc, ok := ret.Get(0).(func(client.ApiDeleteReleasesRequest) *http.Response); ok {
		r0 = returnFunc(r)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*http.Response)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(client.ApiDeleteReleasesRequest) error); ok {
		r1 = returnFunc(r)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// DeleteReleasesExecute is a helper method to define mock.On call
//   - r client.ApiDeleteReleasesRequest
func (_e *MockDeploymentsV2ManagementAPIAPI_Expecter) DeleteReleasesExecute(r interface{}) *MockDeploymentsV2ManagementAPIAPI_DeleteReleasesExecute_Call {
	return &MockDeploymentsV2ManagementAPIAPI_DeleteReleasesExecute_Call{Call: _e.mock.On("DeleteReleasesExecute", r)}
}

func (_c *MockDeploymentsV2ManagementAPIAPI_DeleteReleasesExecute_Call) Run(run func(r client.ApiDeleteReleasesRequest)) *MockDeploymentsV2ManagementAPIAPI_DeleteReleasesExecute_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 client.ApiDeleteReleasesRequest
		if args[0] != nil {
			arg0 = args[0].(client.ApiDeleteReleasesRequest)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *MockDeploymentsV2ManagementAPIAPI_DeleteReleasesExecute_Call) Return(response *http.Response, err error) *MockDeploymentsV2ManagementAPIAPI_DeleteReleasesExecute_Call {
	_c.Call.Return(response, err)
	return _c
}

func (_c *MockDeploymentsV2ManagementAPIAPI_DeleteReleasesExecute_Call) RunAndReturn(run func(r client.ApiDeleteReleasesRequest) (*http.Response, error)) *MockDeploymentsV2ManagementAPIAPI_DeleteReleasesExecute_Call {
	_c.Call.Return(run)
	return _c
}

// DeploymentsV2ListArtifactsWithPagination provides a mock function for the type MockDeploymentsV2ManagementAPIAPI
func (_mock *MockDeploymentsV2ManagementAPIAPI) DeploymentsV2ListArtifactsWithPagination(ctx context.Context) client.ApiDeploymentsV2ListArtifactsWithPaginationRequest {
	ret := _mock.Called(ctx)

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

	var r0 client.ApiDeploymentsV2ListArtifactsWithPaginationRequest
	if returnFunc, ok := ret.Get(0).(func(context.Context) client.ApiDeploymentsV2ListArtifactsWithPaginationRequest); ok {
		r0 = returnFunc(ctx)
	} else {
		r0 = ret.Get(0).(client.ApiDeploymentsV2ListArtifactsWithPaginationRequest)
	}
	return r0
}

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

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

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

func (_c *MockDeploymentsV2ManagementAPIAPI_DeploymentsV2ListArtifactsWithPagination_Call) Return(apiDeploymentsV2ListArtifactsWithPaginationRequest client.ApiDeploymentsV2ListArtifactsWithPaginationRequest) *MockDeploymentsV2ManagementAPIAPI_DeploymentsV2ListArtifactsWithPagination_Call {
	_c.Call.Return(apiDeploymentsV2ListArtifactsWithPaginationRequest)
	return _c
}

func (_c *MockDeploymentsV2ManagementAPIAPI_DeploymentsV2ListArtifactsWithPagination_Call) RunAndReturn(run func(ctx context.Context) client.ApiDeploymentsV2ListArtifactsWithPaginationRequest) *MockDeploymentsV2ManagementAPIAPI_DeploymentsV2ListArtifactsWithPagination_Call {
	_c.Call.Return(run)
	return _c
}

// DeploymentsV2ListArtifactsWithPaginationExecute provides a mock function for the type MockDeploymentsV2ManagementAPIAPI
func (_mock *MockDeploymentsV2ManagementAPIAPI) DeploymentsV2ListArtifactsWithPaginationExecute(r client.ApiDeploymentsV2ListArtifactsWithPaginationRequest) ([]client.ArtifactV2, *http.Response, error) {
	ret := _mock.Called(r)

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

	var r0 []client.ArtifactV2
	var r1 *http.Response
	var r2 error
	if returnFunc, ok := ret.Get(0).(func(client.ApiDeploymentsV2ListArtifactsWithPaginationRequest) ([]client.ArtifactV2, *http.Response, error)); ok {
		return returnFunc(r)
	}
	if returnFunc, ok := ret.Get(0).(func(client.ApiDeploymentsV2ListArtifactsWithPaginationRequest) []client.ArtifactV2); ok {
		r0 = returnFunc(r)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]client.ArtifactV2)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(client.ApiDeploymentsV2ListArtifactsWithPaginationRequest) *http.Response); ok {
		r1 = returnFunc(r)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*http.Response)
		}
	}
	if returnFunc, ok := ret.Get(2).(func(client.ApiDeploymentsV2ListArtifactsWithPaginationRequest) error); ok {
		r2 = returnFunc(r)
	} else {
		r2 = ret.Error(2)
	}
	return r0, r1, r2
}

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

// DeploymentsV2ListArtifactsWithPaginationExecute is a helper method to define mock.On call
//   - r client.ApiDeploymentsV2ListArtifactsWithPaginationRequest
func (_e *MockDeploymentsV2ManagementAPIAPI_Expecter) DeploymentsV2ListArtifactsWithPaginationExecute(r interface{}) *MockDeploymentsV2ManagementAPIAPI_DeploymentsV2ListArtifactsWithPaginationExecute_Call {
	return &MockDeploymentsV2ManagementAPIAPI_DeploymentsV2ListArtifactsWithPaginationExecute_Call{Call: _e.mock.On("DeploymentsV2ListArtifactsWithPaginationExecute", r)}
}

func (_c *MockDeploymentsV2ManagementAPIAPI_DeploymentsV2ListArtifactsWithPaginationExecute_Call) Run(run func(r client.ApiDeploymentsV2ListArtifactsWithPaginationRequest)) *MockDeploymentsV2ManagementAPIAPI_DeploymentsV2ListArtifactsWithPaginationExecute_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 client.ApiDeploymentsV2ListArtifactsWithPaginationRequest
		if args[0] != nil {
			arg0 = args[0].(client.ApiDeploymentsV2ListArtifactsWithPaginationRequest)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *MockDeploymentsV2ManagementAPIAPI_DeploymentsV2ListArtifactsWithPaginationExecute_Call) Return(artifactV2s []client.ArtifactV2, response *http.Response, err error) *MockDeploymentsV2ManagementAPIAPI_DeploymentsV2ListArtifactsWithPaginationExecute_Call {
	_c.Call.Return(artifactV2s, response, err)
	return _c
}

func (_c *MockDeploymentsV2ManagementAPIAPI_DeploymentsV2ListArtifactsWithPaginationExecute_Call) RunAndReturn(run func(r client.ApiDeploymentsV2ListArtifactsWithPaginationRequest) ([]client.ArtifactV2, *http.Response, error)) *MockDeploymentsV2ManagementAPIAPI_DeploymentsV2ListArtifactsWithPaginationExecute_Call {
	_c.Call.Return(run)
	return _c
}

// DeploymentsV2ListDeployments provides a mock function for the type MockDeploymentsV2ManagementAPIAPI
func (_mock *MockDeploymentsV2ManagementAPIAPI) DeploymentsV2ListDeployments(ctx context.Context) client.ApiDeploymentsV2ListDeploymentsRequest {
	ret := _mock.Called(ctx)

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

	var r0 client.ApiDeploymentsV2ListDeploymentsRequest
	if returnFunc, ok := ret.Get(0).(func(context.Context) client.ApiDeploymentsV2ListDeploymentsRequest); ok {
		r0 = returnFunc(ctx)
	} else {
		r0 = ret.Get(0).(client.ApiDeploymentsV2ListDeploymentsRequest)
	}
	return r0
}

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

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

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

func (_c *MockDeploymentsV2ManagementAPIAPI_DeploymentsV2ListDeployments_Call) Return(apiDeploymentsV2ListDeploymentsRequest client.ApiDeploymentsV2ListDeploymentsRequest) *MockDeploymentsV2ManagementAPIAPI_DeploymentsV2ListDeployments_Call {
	_c.Call.Return(apiDeploymentsV2ListDeploymentsRequest)
	return _c
}

func (_c *MockDeploymentsV2ManagementAPIAPI_DeploymentsV2ListDeployments_Call) RunAndReturn(run func(ctx context.Context) client.ApiDeploymentsV2ListDeploymentsRequest) *MockDeploymentsV2ManagementAPIAPI_DeploymentsV2ListDeployments_Call {
	_c.Call.Return(run)
	return _c
}

// DeploymentsV2ListDeploymentsExecute provides a mock function for the type MockDeploymentsV2ManagementAPIAPI
func (_mock *MockDeploymentsV2ManagementAPIAPI) DeploymentsV2ListDeploymentsExecute(r client.ApiDeploymentsV2ListDeploymentsRequest) ([]client.DeploymentV2, *http.Response, error) {
	ret := _mock.Called(r)

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

	var r0 []client.DeploymentV2
	var r1 *http.Response
	var r2 error
	if returnFunc, ok := ret.Get(0).(func(client.ApiDeploymentsV2ListDeploymentsRequest) ([]client.DeploymentV2, *http.Response, error)); ok {
		return returnFunc(r)
	}
	if returnFunc, ok := ret.Get(0).(func(client.ApiDeploymentsV2ListDeploymentsRequest) []client.DeploymentV2); ok {
		r0 = returnFunc(r)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]client.DeploymentV2)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(client.ApiDeploymentsV2ListDeploymentsRequest) *http.Response); ok {
		r1 = returnFunc(r)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*http.Response)
		}
	}
	if returnFunc, ok := ret.Get(2).(func(client.ApiDeploymentsV2ListDeploymentsRequest) error); ok {
		r2 = returnFunc(r)
	} else {
		r2 = ret.Error(2)
	}
	return r0, r1, r2
}

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

// DeploymentsV2ListDeploymentsExecute is a helper method to define mock.On call
//   - r client.ApiDeploymentsV2ListDeploymentsRequest
func (_e *MockDeploymentsV2ManagementAPIAPI_Expecter) DeploymentsV2ListDeploymentsExecute(r interface{}) *MockDeploymentsV2ManagementAPIAPI_DeploymentsV2ListDeploymentsExecute_Call {
	return &MockDeploymentsV2ManagementAPIAPI_DeploymentsV2ListDeploymentsExecute_Call{Call: _e.mock.On("DeploymentsV2ListDeploymentsExecute", r)}
}

func (_c *MockDeploymentsV2ManagementAPIAPI_DeploymentsV2ListDeploymentsExecute_Call) Run(run func(r client.ApiDeploymentsV2ListDeploymentsRequest)) *MockDeploymentsV2ManagementAPIAPI_DeploymentsV2ListDeploymentsExecute_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 client.ApiDeploymentsV2ListDeploymentsRequest
		if args[0] != nil {
			arg0 = args[0].(client.ApiDeploymentsV2ListDeploymentsRequest)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *MockDeploymentsV2ManagementAPIAPI_DeploymentsV2ListDeploymentsExecute_Call) Return(deploymentV2s []client.DeploymentV2, response *http.Response, err error) *MockDeploymentsV2ManagementAPIAPI_DeploymentsV2ListDeploymentsExecute_Call {
	_c.Call.Return(deploymentV2s, response, err)
	return _c
}

func (_c *MockDeploymentsV2ManagementAPIAPI_DeploymentsV2ListDeploymentsExecute_Call) RunAndReturn(run func(r client.ApiDeploymentsV2ListDeploymentsRequest) ([]client.DeploymentV2, *http.Response, error)) *MockDeploymentsV2ManagementAPIAPI_DeploymentsV2ListDeploymentsExecute_Call {
	_c.Call.Return(run)
	return _c
}

// DeploymentsV2ListReleasesWithPagination provides a mock function for the type MockDeploymentsV2ManagementAPIAPI
func (_mock *MockDeploymentsV2ManagementAPIAPI) DeploymentsV2ListReleasesWithPagination(ctx context.Context) client.ApiDeploymentsV2ListReleasesWithPaginationRequest {
	ret := _mock.Called(ctx)

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

	var r0 client.ApiDeploymentsV2ListReleasesWithPaginationRequest
	if returnFunc, ok := ret.Get(0).(func(context.Context) client.ApiDeploymentsV2ListReleasesWithPaginationRequest); ok {
		r0 = returnFunc(ctx)
	} else {
		r0 = ret.Get(0).(client.ApiDeploymentsV2ListReleasesWithPaginationRequest)
	}
	return r0
}

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

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

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

func (_c *MockDeploymentsV2ManagementAPIAPI_DeploymentsV2ListReleasesWithPagination_Call) Return(apiDeploymentsV2ListReleasesWithPaginationRequest client.ApiDeploymentsV2ListReleasesWithPaginationRequest) *MockDeploymentsV2ManagementAPIAPI_DeploymentsV2ListReleasesWithPagination_Call {
	_c.Call.Return(apiDeploymentsV2ListReleasesWithPaginationRequest)
	return _c
}

func (_c *MockDeploymentsV2ManagementAPIAPI_DeploymentsV2ListReleasesWithPagination_Call) RunAndReturn(run func(ctx context.Context) client.ApiDeploymentsV2ListReleasesWithPaginationRequest) *MockDeploymentsV2ManagementAPIAPI_DeploymentsV2ListReleasesWithPagination_Call {
	_c.Call.Return(run)
	return _c
}

// DeploymentsV2ListReleasesWithPaginationExecute provides a mock function for the type MockDeploymentsV2ManagementAPIAPI
func (_mock *MockDeploymentsV2ManagementAPIAPI) DeploymentsV2ListReleasesWithPaginationExecute(r client.ApiDeploymentsV2ListReleasesWithPaginationRequest) ([]client.ReleaseV2, *http.Response, error) {
	ret := _mock.Called(r)

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

	var r0 []client.ReleaseV2
	var r1 *http.Response
	var r2 error
	if returnFunc, ok := ret.Get(0).(func(client.ApiDeploymentsV2ListReleasesWithPaginationRequest) ([]client.ReleaseV2, *http.Response, error)); ok {
		return returnFunc(r)
	}
	if returnFunc, ok := ret.Get(0).(func(client.ApiDeploymentsV2ListReleasesWithPaginationRequest) []client.ReleaseV2); ok {
		r0 = returnFunc(r)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]client.ReleaseV2)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(client.ApiDeploymentsV2ListReleasesWithPaginationRequest) *http.Response); ok {
		r1 = returnFunc(r)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*http.Response)
		}
	}
	if returnFunc, ok := ret.Get(2).(func(client.ApiDeploymentsV2ListReleasesWithPaginationRequest) error); ok {
		r2 = returnFunc(r)
	} else {
		r2 = ret.Error(2)
	}
	return r0, r1, r2
}

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

// DeploymentsV2ListReleasesWithPaginationExecute is a helper method to define mock.On call
//   - r client.ApiDeploymentsV2ListReleasesWithPaginationRequest
func (_e *MockDeploymentsV2ManagementAPIAPI_Expecter) DeploymentsV2ListReleasesWithPaginationExecute(r interface{}) *MockDeploymentsV2ManagementAPIAPI_DeploymentsV2ListReleasesWithPaginationExecute_Call {
	return &MockDeploymentsV2ManagementAPIAPI_DeploymentsV2ListReleasesWithPaginationExecute_Call{Call: _e.mock.On("DeploymentsV2ListReleasesWithPaginationExecute", r)}
}

func (_c *MockDeploymentsV2ManagementAPIAPI_DeploymentsV2ListReleasesWithPaginationExecute_Call) Run(run func(r client.ApiDeploymentsV2ListReleasesWithPaginationRequest)) *MockDeploymentsV2ManagementAPIAPI_DeploymentsV2ListReleasesWithPaginationExecute_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 client.ApiDeploymentsV2ListReleasesWithPaginationRequest
		if args[0] != nil {
			arg0 = args[0].(client.ApiDeploymentsV2ListReleasesWithPaginationRequest)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *MockDeploymentsV2ManagementAPIAPI_DeploymentsV2ListReleasesWithPaginationExecute_Call) Return(releaseV2s []client.ReleaseV2, response *http.Response, err error) *MockDeploymentsV2ManagementAPIAPI_DeploymentsV2ListReleasesWithPaginationExecute_Call {
	_c.Call.Return(releaseV2s, response, err)
	return _c
}

func (_c *MockDeploymentsV2ManagementAPIAPI_DeploymentsV2ListReleasesWithPaginationExecute_Call) RunAndReturn(run func(r client.ApiDeploymentsV2ListReleasesWithPaginationRequest) ([]client.ReleaseV2, *http.Response, error)) *MockDeploymentsV2ManagementAPIAPI_DeploymentsV2ListReleasesWithPaginationExecute_Call {
	_c.Call.Return(run)
	return _c
}

// GetReleaseWithGivenName provides a mock function for the type MockDeploymentsV2ManagementAPIAPI
func (_mock *MockDeploymentsV2ManagementAPIAPI) GetReleaseWithGivenName(ctx context.Context, releaseName string) client.ApiGetReleaseWithGivenNameRequest {
	ret := _mock.Called(ctx, releaseName)

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

	var r0 client.ApiGetReleaseWithGivenNameRequest
	if returnFunc, ok := ret.Get(0).(func(context.Context, string) client.ApiGetReleaseWithGivenNameRequest); ok {
		r0 = returnFunc(ctx, releaseName)
	} else {
		r0 = ret.Get(0).(client.ApiGetReleaseWithGivenNameRequest)
	}
	return r0
}

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

// GetReleaseWithGivenName is a helper method to define mock.On call
//   - ctx context.Context
//   - releaseName string
func (_e *MockDeploymentsV2ManagementAPIAPI_Expecter) GetReleaseWithGivenName(ctx interface{}, releaseName interface{}) *MockDeploymentsV2ManagementAPIAPI_GetReleaseWithGivenName_Call {
	return &MockDeploymentsV2ManagementAPIAPI_GetReleaseWithGivenName_Call{Call: _e.mock.On("GetReleaseWithGivenName", ctx, releaseName)}
}

func (_c *MockDeploymentsV2ManagementAPIAPI_GetReleaseWithGivenName_Call) Run(run func(ctx context.Context, releaseName string)) *MockDeploymentsV2ManagementAPIAPI_GetReleaseWithGivenName_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 *MockDeploymentsV2ManagementAPIAPI_GetReleaseWithGivenName_Call) Return(apiGetReleaseWithGivenNameRequest client.ApiGetReleaseWithGivenNameRequest) *MockDeploymentsV2ManagementAPIAPI_GetReleaseWithGivenName_Call {
	_c.Call.Return(apiGetReleaseWithGivenNameRequest)
	return _c
}

func (_c *MockDeploymentsV2ManagementAPIAPI_GetReleaseWithGivenName_Call) RunAndReturn(run func(ctx context.Context, releaseName string) client.ApiGetReleaseWithGivenNameRequest) *MockDeploymentsV2ManagementAPIAPI_GetReleaseWithGivenName_Call {
	_c.Call.Return(run)
	return _c
}

// GetReleaseWithGivenNameExecute provides a mock function for the type MockDeploymentsV2ManagementAPIAPI
func (_mock *MockDeploymentsV2ManagementAPIAPI) GetReleaseWithGivenNameExecute(r client.ApiGetReleaseWithGivenNameRequest) (*client.ReleaseV2, *http.Response, error) {
	ret := _mock.Called(r)

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

	var r0 *client.ReleaseV2
	var r1 *http.Response
	var r2 error
	if returnFunc, ok := ret.Get(0).(func(client.ApiGetReleaseWithGivenNameRequest) (*client.ReleaseV2, *http.Response, error)); ok {
		return returnFunc(r)
	}
	if returnFunc, ok := ret.Get(0).(func(client.ApiGetReleaseWithGivenNameRequest) *client.ReleaseV2); ok {
		r0 = returnFunc(r)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*client.ReleaseV2)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(client.ApiGetReleaseWithGivenNameRequest) *http.Response); ok {
		r1 = returnFunc(r)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*http.Response)
		}
	}
	if returnFunc, ok := ret.Get(2).(func(client.ApiGetReleaseWithGivenNameRequest) error); ok {
		r2 = returnFunc(r)
	} else {
		r2 = ret.Error(2)
	}
	return r0, r1, r2
}

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

// GetReleaseWithGivenNameExecute is a helper method to define mock.On call
//   - r client.ApiGetReleaseWithGivenNameRequest
func (_e *MockDeploymentsV2ManagementAPIAPI_Expecter) GetReleaseWithGivenNameExecute(r interface{}) *MockDeploymentsV2ManagementAPIAPI_GetReleaseWithGivenNameExecute_Call {
	return &MockDeploymentsV2ManagementAPIAPI_GetReleaseWithGivenNameExecute_Call{Call: _e.mock.On("GetReleaseWithGivenNameExecute", r)}
}

func (_c *MockDeploymentsV2ManagementAPIAPI_GetReleaseWithGivenNameExecute_Call) Run(run func(r client.ApiGetReleaseWithGivenNameRequest)) *MockDeploymentsV2ManagementAPIAPI_GetReleaseWithGivenNameExecute_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 client.ApiGetReleaseWithGivenNameRequest
		if args[0] != nil {
			arg0 = args[0].(client.ApiGetReleaseWithGivenNameRequest)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *MockDeploymentsV2ManagementAPIAPI_GetReleaseWithGivenNameExecute_Call) Return(releaseV2 *client.ReleaseV2, response *http.Response, err error) *MockDeploymentsV2ManagementAPIAPI_GetReleaseWithGivenNameExecute_Call {
	_c.Call.Return(releaseV2, response, err)
	return _c
}

func (_c *MockDeploymentsV2ManagementAPIAPI_GetReleaseWithGivenNameExecute_Call) RunAndReturn(run func(r client.ApiGetReleaseWithGivenNameRequest) (*client.ReleaseV2, *http.Response, error)) *MockDeploymentsV2ManagementAPIAPI_GetReleaseWithGivenNameExecute_Call {
	_c.Call.Return(run)
	return _c
}

// ListReleaseTags provides a mock function for the type MockDeploymentsV2ManagementAPIAPI
func (_mock *MockDeploymentsV2ManagementAPIAPI) ListReleaseTags(ctx context.Context) client.ApiListReleaseTagsRequest {
	ret := _mock.Called(ctx)

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

	var r0 client.ApiListReleaseTagsRequest
	if returnFunc, ok := ret.Get(0).(func(context.Context) client.ApiListReleaseTagsRequest); ok {
		r0 = returnFunc(ctx)
	} else {
		r0 = ret.Get(0).(client.ApiListReleaseTagsRequest)
	}
	return r0
}

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

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

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

func (_c *MockDeploymentsV2ManagementAPIAPI_ListReleaseTags_Call) Return(apiListReleaseTagsRequest client.ApiListReleaseTagsRequest) *MockDeploymentsV2ManagementAPIAPI_ListReleaseTags_Call {
	_c.Call.Return(apiListReleaseTagsRequest)
	return _c
}

func (_c *MockDeploymentsV2ManagementAPIAPI_ListReleaseTags_Call) RunAndReturn(run func(ctx context.Context) client.ApiListReleaseTagsRequest) *MockDeploymentsV2ManagementAPIAPI_ListReleaseTags_Call {
	_c.Call.Return(run)
	return _c
}

// ListReleaseTagsExecute provides a mock function for the type MockDeploymentsV2ManagementAPIAPI
func (_mock *MockDeploymentsV2ManagementAPIAPI) ListReleaseTagsExecute(r client.ApiListReleaseTagsRequest) ([]string, *http.Response, error) {
	ret := _mock.Called(r)

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

	var r0 []string
	var r1 *http.Response
	var r2 error
	if returnFunc, ok := ret.Get(0).(func(client.ApiListReleaseTagsRequest) ([]string, *http.Response, error)); ok {
		return returnFunc(r)
	}
	if returnFunc, ok := ret.Get(0).(func(client.ApiListReleaseTagsRequest) []string); ok {
		r0 = returnFunc(r)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]string)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(client.ApiListReleaseTagsRequest) *http.Response); ok {
		r1 = returnFunc(r)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*http.Response)
		}
	}
	if returnFunc, ok := ret.Get(2).(func(client.ApiListReleaseTagsRequest) error); ok {
		r2 = returnFunc(r)
	} else {
		r2 = ret.Error(2)
	}
	return r0, r1, r2
}

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

// ListReleaseTagsExecute is a helper method to define mock.On call
//   - r client.ApiListReleaseTagsRequest
func (_e *MockDeploymentsV2ManagementAPIAPI_Expecter) ListReleaseTagsExecute(r interface{}) *MockDeploymentsV2ManagementAPIAPI_ListReleaseTagsExecute_Call {
	return &MockDeploymentsV2ManagementAPIAPI_ListReleaseTagsExecute_Call{Call: _e.mock.On("ListReleaseTagsExecute", r)}
}

func (_c *MockDeploymentsV2ManagementAPIAPI_ListReleaseTagsExecute_Call) Run(run func(r client.ApiListReleaseTagsRequest)) *MockDeploymentsV2ManagementAPIAPI_ListReleaseTagsExecute_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 client.ApiListReleaseTagsRequest
		if args[0] != nil {
			arg0 = args[0].(client.ApiListReleaseTagsRequest)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *MockDeploymentsV2ManagementAPIAPI_ListReleaseTagsExecute_Call) Return(strings []string, response *http.Response, err error) *MockDeploymentsV2ManagementAPIAPI_ListReleaseTagsExecute_Call {
	_c.Call.Return(strings, response, err)
	return _c
}

func (_c *MockDeploymentsV2ManagementAPIAPI_ListReleaseTagsExecute_Call) RunAndReturn(run func(r client.ApiListReleaseTagsRequest) ([]string, *http.Response, error)) *MockDeploymentsV2ManagementAPIAPI_ListReleaseTagsExecute_Call {
	_c.Call.Return(run)
	return _c
}

// ListReleaseTypes provides a mock function for the type MockDeploymentsV2ManagementAPIAPI
func (_mock *MockDeploymentsV2ManagementAPIAPI) ListReleaseTypes(ctx context.Context) client.ApiListReleaseTypesRequest {
	ret := _mock.Called(ctx)

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

	var r0 client.ApiListReleaseTypesRequest
	if returnFunc, ok := ret.Get(0).(func(context.Context) client.ApiListReleaseTypesRequest); ok {
		r0 = returnFunc(ctx)
	} else {
		r0 = ret.Get(0).(client.ApiListReleaseTypesRequest)
	}
	return r0
}

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

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

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

func (_c *MockDeploymentsV2ManagementAPIAPI_ListReleaseTypes_Call) Return(apiListReleaseTypesRequest client.ApiListReleaseTypesRequest) *MockDeploymentsV2ManagementAPIAPI_ListReleaseTypes_Call {
	_c.Call.Return(apiListReleaseTypesRequest)
	return _c
}

func (_c *MockDeploymentsV2ManagementAPIAPI_ListReleaseTypes_Call) RunAndReturn(run func(ctx context.Context) client.ApiListReleaseTypesRequest) *MockDeploymentsV2ManagementAPIAPI_ListReleaseTypes_Call {
	_c.Call.Return(run)
	return _c
}

// ListReleaseTypesExecute provides a mock function for the type MockDeploymentsV2ManagementAPIAPI
func (_mock *MockDeploymentsV2ManagementAPIAPI) ListReleaseTypesExecute(r client.ApiListReleaseTypesRequest) ([]string, *http.Response, error) {
	ret := _mock.Called(r)

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

	var r0 []string
	var r1 *http.Response
	var r2 error
	if returnFunc, ok := ret.Get(0).(func(client.ApiListReleaseTypesRequest) ([]string, *http.Response, error)); ok {
		return returnFunc(r)
	}
	if returnFunc, ok := ret.Get(0).(func(client.ApiListReleaseTypesRequest) []string); ok {
		r0 = returnFunc(r)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]string)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(client.ApiListReleaseTypesRequest) *http.Response); ok {
		r1 = returnFunc(r)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*http.Response)
		}
	}
	if returnFunc, ok := ret.Get(2).(func(client.ApiListReleaseTypesRequest) error); ok {
		r2 = returnFunc(r)
	} else {
		r2 = ret.Error(2)
	}
	return r0, r1, r2
}

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

// ListReleaseTypesExecute is a helper method to define mock.On call
//   - r client.ApiListReleaseTypesRequest
func (_e *MockDeploymentsV2ManagementAPIAPI_Expecter) ListReleaseTypesExecute(r interface{}) *MockDeploymentsV2ManagementAPIAPI_ListReleaseTypesExecute_Call {
	return &MockDeploymentsV2ManagementAPIAPI_ListReleaseTypesExecute_Call{Call: _e.mock.On("ListReleaseTypesExecute", r)}
}

func (_c *MockDeploymentsV2ManagementAPIAPI_ListReleaseTypesExecute_Call) Run(run func(r client.ApiListReleaseTypesRequest)) *MockDeploymentsV2ManagementAPIAPI_ListReleaseTypesExecute_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 client.ApiListReleaseTypesRequest
		if args[0] != nil {
			arg0 = args[0].(client.ApiListReleaseTypesRequest)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *MockDeploymentsV2ManagementAPIAPI_ListReleaseTypesExecute_Call) Return(strings []string, response *http.Response, err error) *MockDeploymentsV2ManagementAPIAPI_ListReleaseTypesExecute_Call {
	_c.Call.Return(strings, response, err)
	return _c
}

func (_c *MockDeploymentsV2ManagementAPIAPI_ListReleaseTypesExecute_Call) RunAndReturn(run func(r client.ApiListReleaseTypesRequest) ([]string, *http.Response, error)) *MockDeploymentsV2ManagementAPIAPI_ListReleaseTypesExecute_Call {
	_c.Call.Return(run)
	return _c
}

// UpdateReleaseInformation provides a mock function for the type MockDeploymentsV2ManagementAPIAPI
func (_mock *MockDeploymentsV2ManagementAPIAPI) UpdateReleaseInformation(ctx context.Context, releaseName string) client.ApiUpdateReleaseInformationRequest {
	ret := _mock.Called(ctx, releaseName)

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

	var r0 client.ApiUpdateReleaseInformationRequest
	if returnFunc, ok := ret.Get(0).(func(context.Context, string) client.ApiUpdateReleaseInformationRequest); ok {
		r0 = returnFunc(ctx, releaseName)
	} else {
		r0 = ret.Get(0).(client.ApiUpdateReleaseInformationRequest)
	}
	return r0
}

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

// UpdateReleaseInformation is a helper method to define mock.On call
//   - ctx context.Context
//   - releaseName string
func (_e *MockDeploymentsV2ManagementAPIAPI_Expecter) UpdateReleaseInformation(ctx interface{}, releaseName interface{}) *MockDeploymentsV2ManagementAPIAPI_UpdateReleaseInformation_Call {
	return &MockDeploymentsV2ManagementAPIAPI_UpdateReleaseInformation_Call{Call: _e.mock.On("UpdateReleaseInformation", ctx, releaseName)}
}

func (_c *MockDeploymentsV2ManagementAPIAPI_UpdateReleaseInformation_Call) Run(run func(ctx context.Context, releaseName string)) *MockDeploymentsV2ManagementAPIAPI_UpdateReleaseInformation_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 *MockDeploymentsV2ManagementAPIAPI_UpdateReleaseInformation_Call) Return(apiUpdateReleaseInformationRequest client.ApiUpdateReleaseInformationRequest) *MockDeploymentsV2ManagementAPIAPI_UpdateReleaseInformation_Call {
	_c.Call.Return(apiUpdateReleaseInformationRequest)
	return _c
}

func (_c *MockDeploymentsV2ManagementAPIAPI_UpdateReleaseInformation_Call) RunAndReturn(run func(ctx context.Context, releaseName string) client.ApiUpdateReleaseInformationRequest) *MockDeploymentsV2ManagementAPIAPI_UpdateReleaseInformation_Call {
	_c.Call.Return(run)
	return _c
}

// UpdateReleaseInformationExecute provides a mock function for the type MockDeploymentsV2ManagementAPIAPI
func (_mock *MockDeploymentsV2ManagementAPIAPI) UpdateReleaseInformationExecute(r client.ApiUpdateReleaseInformationRequest) (*http.Response, error) {
	ret := _mock.Called(r)

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

	var r0 *http.Response
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(client.ApiUpdateReleaseInformationRequest) (*http.Response, error)); ok {
		return returnFunc(r)
	}
	if returnFunc, ok := ret.Get(0).(func(client.ApiUpdateReleaseInformationRequest) *http.Response); ok {
		r0 = returnFunc(r)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*http.Response)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(client.ApiUpdateReleaseInformationRequest) error); ok {
		r1 = returnFunc(r)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// UpdateReleaseInformationExecute is a helper method to define mock.On call
//   - r client.ApiUpdateReleaseInformationRequest
func (_e *MockDeploymentsV2ManagementAPIAPI_Expecter) UpdateReleaseInformationExecute(r interface{}) *MockDeploymentsV2ManagementAPIAPI_UpdateReleaseInformationExecute_Call {
	return &MockDeploymentsV2ManagementAPIAPI_UpdateReleaseInformationExecute_Call{Call: _e.mock.On("UpdateReleaseInformationExecute", r)}
}

func (_c *MockDeploymentsV2ManagementAPIAPI_UpdateReleaseInformationExecute_Call) Run(run func(r client.ApiUpdateReleaseInformationRequest)) *MockDeploymentsV2ManagementAPIAPI_UpdateReleaseInformationExecute_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 client.ApiUpdateReleaseInformationRequest
		if args[0] != nil {
			arg0 = args[0].(client.ApiUpdateReleaseInformationRequest)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *MockDeploymentsV2ManagementAPIAPI_UpdateReleaseInformationExecute_Call) Return(response *http.Response, err error) *MockDeploymentsV2ManagementAPIAPI_UpdateReleaseInformationExecute_Call {
	_c.Call.Return(response, err)
	return _c
}

func (_c *MockDeploymentsV2ManagementAPIAPI_UpdateReleaseInformationExecute_Call) RunAndReturn(run func(r client.ApiUpdateReleaseInformationRequest) (*http.Response, error)) *MockDeploymentsV2ManagementAPIAPI_UpdateReleaseInformationExecute_Call {
	_c.Call.Return(run)
	return _c
}

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

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

	return mock
}

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

type MockDeviceAuthenticationDeviceAPIAPI_Expecter struct {
	mock *mock.Mock
}

func (_m *MockDeviceAuthenticationDeviceAPIAPI) EXPECT() *MockDeviceAuthenticationDeviceAPIAPI_Expecter {
	return &MockDeviceAuthenticationDeviceAPIAPI_Expecter{mock: &_m.Mock}
}

// DeviceAuthAuthenticateDevice provides a mock function for the type MockDeviceAuthenticationDeviceAPIAPI
func (_mock *MockDeviceAuthenticationDeviceAPIAPI) DeviceAuthAuthenticateDevice(ctx context.Context) client.ApiDeviceAuthAuthenticateDeviceRequest {
	ret := _mock.Called(ctx)

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

	var r0 client.ApiDeviceAuthAuthenticateDeviceRequest
	if returnFunc, ok := ret.Get(0).(func(context.Context) client.ApiDeviceAuthAuthenticateDeviceRequest); ok {
		r0 = returnFunc(ctx)
	} else {
		r0 = ret.Get(0).(client.ApiDeviceAuthAuthenticateDeviceRequest)
	}
	return r0
}

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

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

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

func (_c *MockDeviceAuthenticationDeviceAPIAPI_DeviceAuthAuthenticateDevice_Call) Return(apiDeviceAuthAuthenticateDeviceRequest client.ApiDeviceAuthAuthenticateDeviceRequest) *MockDeviceAuthenticationDeviceAPIAPI_DeviceAuthAuthenticateDevice_Call {
	_c.Call.Return(apiDeviceAuthAuthenticateDeviceRequest)
	return _c
}

func (_c *MockDeviceAuthenticationDeviceAPIAPI_DeviceAuthAuthenticateDevice_Call) RunAndReturn(run func(ctx context.Context) client.ApiDeviceAuthAuthenticateDeviceRequest) *MockDeviceAuthenticationDeviceAPIAPI_DeviceAuthAuthenticateDevice_Call {
	_c.Call.Return(run)
	return _c
}

// DeviceAuthAuthenticateDeviceExecute provides a mock function for the type MockDeviceAuthenticationDeviceAPIAPI
func (_mock *MockDeviceAuthenticationDeviceAPIAPI) DeviceAuthAuthenticateDeviceExecute(r client.ApiDeviceAuthAuthenticateDeviceRequest) (string, *http.Response, error) {
	ret := _mock.Called(r)

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

	var r0 string
	var r1 *http.Response
	var r2 error
	if returnFunc, ok := ret.Get(0).(func(client.ApiDeviceAuthAuthenticateDeviceRequest) (string, *http.Response, error)); ok {
		return returnFunc(r)
	}
	if returnFunc, ok := ret.Get(0).(func(client.ApiDeviceAuthAuthenticateDeviceRequest) string); ok {
		r0 = returnFunc(r)
	} else {
		r0 = ret.Get(0).(string)
	}
	if returnFunc, ok := ret.Get(1).(func(client.ApiDeviceAuthAuthenticateDeviceRequest) *http.Response); ok {
		r1 = returnFunc(r)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*http.Response)
		}
	}
	if returnFunc, ok := ret.Get(2).(func(client.ApiDeviceAuthAuthenticateDeviceRequest) error); ok {
		r2 = returnFunc(r)
	} else {
		r2 = ret.Error(2)
	}
	return r0, r1, r2
}

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

// DeviceAuthAuthenticateDeviceExecute is a helper method to define mock.On call
//   - r client.ApiDeviceAuthAuthenticateDeviceRequest
func (_e *MockDeviceAuthenticationDeviceAPIAPI_Expecter) DeviceAuthAuthenticateDeviceExecute(r interface{}) *MockDeviceAuthenticationDeviceAPIAPI_DeviceAuthAuthenticateDeviceExecute_Call {
	return &MockDeviceAuthenticationDeviceAPIAPI_DeviceAuthAuthenticateDeviceExecute_Call{Call: _e.mock.On("DeviceAuthAuthenticateDeviceExecute", r)}
}

func (_c *MockDeviceAuthenticationDeviceAPIAPI_DeviceAuthAuthenticateDeviceExecute_Call) Run(run func(r client.ApiDeviceAuthAuthenticateDeviceRequest)) *MockDeviceAuthenticationDeviceAPIAPI_DeviceAuthAuthenticateDeviceExecute_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 client.ApiDeviceAuthAuthenticateDeviceRequest
		if args[0] != nil {
			arg0 = args[0].(client.ApiDeviceAuthAuthenticateDeviceRequest)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *MockDeviceAuthenticationDeviceAPIAPI_DeviceAuthAuthenticateDeviceExecute_Call) Return(s string, response *http.Response, err error) *MockDeviceAuthenticationDeviceAPIAPI_DeviceAuthAuthenticateDeviceExecute_Call {
	_c.Call.Return(s, response, err)
	return _c
}

func (_c *MockDeviceAuthenticationDeviceAPIAPI_DeviceAuthAuthenticateDeviceExecute_Call) RunAndReturn(run func(r client.ApiDeviceAuthAuthenticateDeviceRequest) (string, *http.Response, error)) *MockDeviceAuthenticationDeviceAPIAPI_DeviceAuthAuthenticateDeviceExecute_Call {
	_c.Call.Return(run)
	return _c
}

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

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

	return mock
}

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

type MockDeviceAuthenticationInternalAPIAPI_Expecter struct {
	mock *mock.Mock
}

func (_m *MockDeviceAuthenticationInternalAPIAPI) EXPECT() *MockDeviceAuthenticationInternalAPIAPI_Expecter {
	return &MockDeviceAuthenticationInternalAPIAPI_Expecter{mock: &_m.Mock}
}

// DeviceAuthInternalCheckHealth provides a mock function for the type MockDeviceAuthenticationInternalAPIAPI
func (_mock *MockDeviceAuthenticationInternalAPIAPI) DeviceAuthInternalCheckHealth(ctx context.Context) client.ApiDeviceAuthInternalCheckHealthRequest {
	ret := _mock.Called(ctx)

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

	var r0 client.ApiDeviceAuthInternalCheckHealthRequest
	if returnFunc, ok := ret.Get(0).(func(context.Context) client.ApiDeviceAuthInternalCheckHealthRequest); ok {
		r0 = returnFunc(ctx)
	} else {
		r0 = ret.Get(0).(client.ApiDeviceAuthInternalCheckHealthRequest)
	}
	return r0
}

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

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

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

func (_c *MockDeviceAuthenticationInternalAPIAPI_DeviceAuthInternalCheckHealth_Call) Return(apiDeviceAuthInternalCheckHealthRequest client.ApiDeviceAuthInternalCheckHealthRequest) *MockDeviceAuthenticationInternalAPIAPI_DeviceAuthInternalCheckHealth_Call {
	_c.Call.Return(apiDeviceAuthInternalCheckHealthRequest)
	return _c
}

func (_c *MockDeviceAuthenticationInternalAPIAPI_DeviceAuthInternalCheckHealth_Call) RunAndReturn(run func(ctx context.Context) client.ApiDeviceAuthInternalCheckHealthRequest) *MockDeviceAuthenticationInternalAPIAPI_DeviceAuthInternalCheckHealth_Call {
	_c.Call.Return(run)
	return _c
}

// DeviceAuthInternalCheckHealthExecute provides a mock function for the type MockDeviceAuthenticationInternalAPIAPI
func (_mock *MockDeviceAuthenticationInternalAPIAPI) DeviceAuthInternalCheckHealthExecute(r client.ApiDeviceAuthInternalCheckHealthRequest) (*http.Response, error) {
	ret := _mock.Called(r)

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

	var r0 *http.Response
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(client.ApiDeviceAuthInternalCheckHealthRequest) (*http.Response, error)); ok {
		return returnFunc(r)
	}
	if returnFunc, ok := ret.Get(0).(func(client.ApiDeviceAuthInternalCheckHealthRequest) *http.Response); ok {
		r0 = returnFunc(r)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*http.Response)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(client.ApiDeviceAuthInternalCheckHealthRequest) error); ok {
		r1 = returnFunc(r)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// DeviceAuthInternalCheckHealthExecute is a helper method to define mock.On call
//   - r client.ApiDeviceAuthInternalCheckHealthRequest
func (_e *MockDeviceAuthenticationInternalAPIAPI_Expecter) DeviceAuthInternalCheckHealthExecute(r interface{}) *MockDeviceAuthenticationInternalAPIAPI_DeviceAuthInternalCheckHealthExecute_Call {
	return &MockDeviceAuthenticationInternalAPIAPI_DeviceAuthInternalCheckHealthExecute_Call{Call: _e.mock.On("DeviceAuthInternalCheckHealthExecute", r)}
}

func (_c *MockDeviceAuthenticationInternalAPIAPI_DeviceAuthInternalCheckHealthExecute_Call) Run(run func(r client.ApiDeviceAuthInternalCheckHealthRequest)) *MockDeviceAuthenticationInternalAPIAPI_DeviceAuthInternalCheckHealthExecute_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 client.ApiDeviceAuthInternalCheckHealthRequest
		if args[0] != nil {
			arg0 = args[0].(client.ApiDeviceAuthInternalCheckHealthRequest)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *MockDeviceAuthenticationInternalAPIAPI_DeviceAuthInternalCheckHealthExecute_Call) Return(response *http.Response, err error) *MockDeviceAuthenticationInternalAPIAPI_DeviceAuthInternalCheckHealthExecute_Call {
	_c.Call.Return(response, err)
	return _c
}

func (_c *MockDeviceAuthenticationInternalAPIAPI_DeviceAuthInternalCheckHealthExecute_Call) RunAndReturn(run func(r client.ApiDeviceAuthInternalCheckHealthRequest) (*http.Response, error)) *MockDeviceAuthenticationInternalAPIAPI_DeviceAuthInternalCheckHealthExecute_Call {
	_c.Call.Return(run)
	return _c
}

// DeviceAuthInternalCheckLiveliness provides a mock function for the type MockDeviceAuthenticationInternalAPIAPI
func (_mock *MockDeviceAuthenticationInternalAPIAPI) DeviceAuthInternalCheckLiveliness(ctx context.Context) client.ApiDeviceAuthInternalCheckLivelinessRequest {
	ret := _mock.Called(ctx)

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

	var r0 client.ApiDeviceAuthInternalCheckLivelinessRequest
	if returnFunc, ok := ret.Get(0).(func(context.Context) client.ApiDeviceAuthInternalCheckLivelinessRequest); ok {
		r0 = returnFunc(ctx)
	} else {
		r0 = ret.Get(0).(client.ApiDeviceAuthInternalCheckLivelinessRequest)
	}
	return r0
}

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

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

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

func (_c *MockDeviceAuthenticationInternalAPIAPI_DeviceAuthInternalCheckLiveliness_Call) Return(apiDeviceAuthInternalCheckLivelinessRequest client.ApiDeviceAuthInternalCheckLivelinessRequest) *MockDeviceAuthenticationInternalAPIAPI_DeviceAuthInternalCheckLiveliness_Call {
	_c.Call.Return(apiDeviceAuthInternalCheckLivelinessRequest)
	return _c
}

func (_c *MockDeviceAuthenticationInternalAPIAPI_DeviceAuthInternalCheckLiveliness_Call) RunAndReturn(run func(ctx context.Context) client.ApiDeviceAuthInternalCheckLivelinessRequest) *MockDeviceAuthenticationInternalAPIAPI_DeviceAuthInternalCheckLiveliness_Call {
	_c.Call.Return(run)
	return _c
}

// DeviceAuthInternalCheckLivelinessExecute provides a mock function for the type MockDeviceAuthenticationInternalAPIAPI
func (_mock *MockDeviceAuthenticationInternalAPIAPI) DeviceAuthInternalCheckLivelinessExecute(r client.ApiDeviceAuthInternalCheckLivelinessRequest) (*http.Response, error) {
	ret := _mock.Called(r)

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

	var r0 *http.Response
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(client.ApiDeviceAuthInternalCheckLivelinessRequest) (*http.Response, error)); ok {
		return returnFunc(r)
	}
	if returnFunc, ok := ret.Get(0).(func(client.ApiDeviceAuthInternalCheckLivelinessRequest) *http.Response); ok {
		r0 = returnFunc(r)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*http.Response)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(client.ApiDeviceAuthInternalCheckLivelinessRequest) error); ok {
		r1 = returnFunc(r)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// DeviceAuthInternalCheckLivelinessExecute is a helper method to define mock.On call
//   - r client.ApiDeviceAuthInternalCheckLivelinessRequest
func (_e *MockDeviceAuthenticationInternalAPIAPI_Expecter) DeviceAuthInternalCheckLivelinessExecute(r interface{}) *MockDeviceAuthenticationInternalAPIAPI_DeviceAuthInternalCheckLivelinessExecute_Call {
	return &MockDeviceAuthenticationInternalAPIAPI_DeviceAuthInternalCheckLivelinessExecute_Call{Call: _e.mock.On("DeviceAuthInternalCheckLivelinessExecute", r)}
}

func (_c *MockDeviceAuthenticationInternalAPIAPI_DeviceAuthInternalCheckLivelinessExecute_Call) Run(run func(r client.ApiDeviceAuthInternalCheckLivelinessRequest)) *MockDeviceAuthenticationInternalAPIAPI_DeviceAuthInternalCheckLivelinessExecute_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 client.ApiDeviceAuthInternalCheckLivelinessRequest
		if args[0] != nil {
			arg0 = args[0].(client.ApiDeviceAuthInternalCheckLivelinessRequest)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *MockDeviceAuthenticationInternalAPIAPI_DeviceAuthInternalCheckLivelinessExecute_Call) Return(response *http.Response, err error) *MockDeviceAuthenticationInternalAPIAPI_DeviceAuthInternalCheckLivelinessExecute_Call {
	_c.Call.Return(response, err)
	return _c
}

func (_c *MockDeviceAuthenticationInternalAPIAPI_DeviceAuthInternalCheckLivelinessExecute_Call) RunAndReturn(run func(r client.ApiDeviceAuthInternalCheckLivelinessRequest) (*http.Response, error)) *MockDeviceAuthenticationInternalAPIAPI_DeviceAuthInternalCheckLivelinessExecute_Call {
	_c.Call.Return(run)
	return _c
}

// DeviceAuthInternalClearDeviceLimit provides a mock function for the type MockDeviceAuthenticationInternalAPIAPI
func (_mock *MockDeviceAuthenticationInternalAPIAPI) DeviceAuthInternalClearDeviceLimit(ctx context.Context, tenantId string) client.ApiDeviceAuthInternalClearDeviceLimitRequest {
	ret := _mock.Called(ctx, tenantId)

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

	var r0 client.ApiDeviceAuthInternalClearDeviceLimitRequest
	if returnFunc, ok := ret.Get(0).(func(context.Context, string) client.ApiDeviceAuthInternalClearDeviceLimitRequest); ok {
		r0 = returnFunc(ctx, tenantId)
	} else {
		r0 = ret.Get(0).(client.ApiDeviceAuthInternalClearDeviceLimitRequest)
	}
	return r0
}

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

// DeviceAuthInternalClearDeviceLimit is a helper method to define mock.On call
//   - ctx context.Context
//   - tenantId string
func (_e *MockDeviceAuthenticationInternalAPIAPI_Expecter) DeviceAuthInternalClearDeviceLimit(ctx interface{}, tenantId interface{}) *MockDeviceAuthenticationInternalAPIAPI_DeviceAuthInternalClearDeviceLimit_Call {
	return &MockDeviceAuthenticationInternalAPIAPI_DeviceAuthInternalClearDeviceLimit_Call{Call: _e.mock.On("DeviceAuthInternalClearDeviceLimit", ctx, tenantId)}
}

func (_c *MockDeviceAuthenticationInternalAPIAPI_DeviceAuthInternalClearDeviceLimit_Call) Run(run func(ctx context.Context, tenantId string)) *MockDeviceAuthenticationInternalAPIAPI_DeviceAuthInternalClearDeviceLimit_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 *MockDeviceAuthenticationInternalAPIAPI_DeviceAuthInternalClearDeviceLimit_Call) Return(apiDeviceAuthInternalClearDeviceLimitRequest client.ApiDeviceAuthInternalClearDeviceLimitRequest) *MockDeviceAuthenticationInternalAPIAPI_DeviceAuthInternalClearDeviceLimit_Call {
	_c.Call.Return(apiDeviceAuthInternalClearDeviceLimitRequest)
	return _c
}

func (_c *MockDeviceAuthenticationInternalAPIAPI_DeviceAuthInternalClearDeviceLimit_Call) RunAndReturn(run func(ctx context.Context, tenantId string) client.ApiDeviceAuthInternalClearDeviceLimitRequest) *MockDeviceAuthenticationInternalAPIAPI_DeviceAuthInternalClearDeviceLimit_Call {
	_c.Call.Return(run)
	return _c
}

// DeviceAuthInternalClearDeviceLimitExecute provides a mock function for the type MockDeviceAuthenticationInternalAPIAPI
func (_mock *MockDeviceAuthenticationInternalAPIAPI) DeviceAuthInternalClearDeviceLimitExecute(r client.ApiDeviceAuthInternalClearDeviceLimitRequest) (*http.Response, error) {
	ret := _mock.Called(r)

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

	var r0 *http.Response
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(client.ApiDeviceAuthInternalClearDeviceLimitRequest) (*http.Response, error)); ok {
		return returnFunc(r)
	}
	if returnFunc, ok := ret.Get(0).(func(client.ApiDeviceAuthInternalClearDeviceLimitRequest) *http.Response); ok {
		r0 = returnFunc(r)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*http.Response)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(client.ApiDeviceAuthInternalClearDeviceLimitRequest) error); ok {
		r1 = returnFunc(r)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// DeviceAuthInternalClearDeviceLimitExecute is a helper method to define mock.On call
//   - r client.ApiDeviceAuthInternalClearDeviceLimitRequest
func (_e *MockDeviceAuthenticationInternalAPIAPI_Expecter) DeviceAuthInternalClearDeviceLimitExecute(r interface{}) *MockDeviceAuthenticationInternalAPIAPI_DeviceAuthInternalClearDeviceLimitExecute_Call {
	return &MockDeviceAuthenticationInternalAPIAPI_DeviceAuthInternalClearDeviceLimitExecute_Call{Call: _e.mock.On("DeviceAuthInternalClearDeviceLimitExecute", r)}
}

func (_c *MockDeviceAuthenticationInternalAPIAPI_DeviceAuthInternalClearDeviceLimitExecute_Call) Run(run func(r client.ApiDeviceAuthInternalClearDeviceLimitRequest)) *MockDeviceAuthenticationInternalAPIAPI_DeviceAuthInternalClearDeviceLimitExecute_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 client.ApiDeviceAuthInternalClearDeviceLimitRequest
		if args[0] != nil {
			arg0 = args[0].(client.ApiDeviceAuthInternalClearDeviceLimitRequest)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *MockDeviceAuthenticationInternalAPIAPI_DeviceAuthInternalClearDeviceLimitExecute_Call) Return(response *http.Response, err error) *MockDeviceAuthenticationInternalAPIAPI_DeviceAuthInternalClearDeviceLimitExecute_Call {
	_c.Call.Return(response, err)
	return _c
}

func (_c *MockDeviceAuthenticationInternalAPIAPI_DeviceAuthInternalClearDeviceLimitExecute_Call) RunAndReturn(run func(r client.ApiDeviceAuthInternalClearDeviceLimitRequest) (*http.Response, error)) *MockDeviceAuthenticationInternalAPIAPI_DeviceAuthInternalClearDeviceLimitExecute_Call {
	_c.Call.Return(run)
	return _c
}

// DeviceAuthInternalCountDevices provides a mock function for the type MockDeviceAuthenticationInternalAPIAPI
func (_mock *MockDeviceAuthenticationInternalAPIAPI) DeviceAuthInternalCountDevices(ctx context.Context, tid string) client.ApiDeviceAuthInternalCountDevicesRequest {
	ret := _mock.Called(ctx, tid)

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

	var r0 client.ApiDeviceAuthInternalCountDevicesRequest
	if returnFunc, ok := ret.Get(0).(func(context.Context, string) client.ApiDeviceAuthInternalCountDevicesRequest); ok {
		r0 = returnFunc(ctx, tid)
	} else {
		r0 = ret.Get(0).(client.ApiDeviceAuthInternalCountDevicesRequest)
	}
	return r0
}

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

// DeviceAuthInternalCountDevices is a helper method to define mock.On call
//   - ctx context.Context
//   - tid string
func (_e *MockDeviceAuthenticationInternalAPIAPI_Expecter) DeviceAuthInternalCountDevices(ctx interface{}, tid interface{}) *MockDeviceAuthenticationInternalAPIAPI_DeviceAuthInternalCountDevices_Call {
	return &MockDeviceAuthenticationInternalAPIAPI_DeviceAuthInternalCountDevices_Call{Call: _e.mock.On("DeviceAuthInternalCountDevices", ctx, tid)}
}

func (_c *MockDeviceAuthenticationInternalAPIAPI_DeviceAuthInternalCountDevices_Call) Run(run func(ctx context.Context, tid string)) *MockDeviceAuthenticationInternalAPIAPI_DeviceAuthInternalCountDevices_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 *MockDeviceAuthenticationInternalAPIAPI_DeviceAuthInternalCountDevices_Call) Return(apiDeviceAuthInternalCountDevicesRequest client.ApiDeviceAuthInternalCountDevicesRequest) *MockDeviceAuthenticationInternalAPIAPI_DeviceAuthInternalCountDevices_Call {
	_c.Call.Return(apiDeviceAuthInternalCountDevicesRequest)
	return _c
}

func (_c *MockDeviceAuthenticationInternalAPIAPI_DeviceAuthInternalCountDevices_Call) RunAndReturn(run func(ctx context.Context, tid string) client.ApiDeviceAuthInternalCountDevicesRequest) *MockDeviceAuthenticationInternalAPIAPI_DeviceAuthInternalCountDevices_Call {
	_c.Call.Return(run)
	return _c
}

// DeviceAuthInternalCountDevicesExecute provides a mock function for the type MockDeviceAuthenticationInternalAPIAPI
func (_mock *MockDeviceAuthenticationInternalAPIAPI) DeviceAuthInternalCountDevicesExecute(r client.ApiDeviceAuthInternalCountDevicesRequest) (*client.Count, *http.Response, error) {
	ret := _mock.Called(r)

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

	var r0 *client.Count
	var r1 *http.Response
	var r2 error
	if returnFunc, ok := ret.Get(0).(func(client.ApiDeviceAuthInternalCountDevicesRequest) (*client.Count, *http.Response, error)); ok {
		return returnFunc(r)
	}
	if returnFunc, ok := ret.Get(0).(func(client.ApiDeviceAuthInternalCountDevicesRequest) *client.Count); ok {
		r0 = returnFunc(r)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*client.Count)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(client.ApiDeviceAuthInternalCountDevicesRequest) *http.Response); ok {
		r1 = returnFunc(r)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*http.Response)
		}
	}
	if returnFunc, ok := ret.Get(2).(func(client.ApiDeviceAuthInternalCountDevicesRequest) error); ok {
		r2 = returnFunc(r)
	} else {
		r2 = ret.Error(2)
	}
	return r0, r1, r2
}

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

// DeviceAuthInternalCountDevicesExecute is a helper method to define mock.On call
//   - r client.ApiDeviceAuthInternalCountDevicesRequest
func (_e *MockDeviceAuthenticationInternalAPIAPI_Expecter) DeviceAuthInternalCountDevicesExecute(r interface{}) *MockDeviceAuthenticationInternalAPIAPI_DeviceAuthInternalCountDevicesExecute_Call {
	return &MockDeviceAuthenticationInternalAPIAPI_DeviceAuthInternalCountDevicesExecute_Call{Call: _e.mock.On("DeviceAuthInternalCountDevicesExecute", r)}
}

func (_c *MockDeviceAuthenticationInternalAPIAPI_DeviceAuthInternalCountDevicesExecute_Call) Run(run func(r client.ApiDeviceAuthInternalCountDevicesRequest)) *MockDeviceAuthenticationInternalAPIAPI_DeviceAuthInternalCountDevicesExecute_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 client.ApiDeviceAuthInternalCountDevicesRequest
		if args[0] != nil {
			arg0 = args[0].(client.ApiDeviceAuthInternalCountDevicesRequest)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *MockDeviceAuthenticationInternalAPIAPI_DeviceAuthInternalCountDevicesExecute_Call) Return(count *client.Count, response *http.Response, err error) *MockDeviceAuthenticationInternalAPIAPI_DeviceAuthInternalCountDevicesExecute_Call {
	_c.Call.Return(count, response, err)
	return _c
}

func (_c *MockDeviceAuthenticationInternalAPIAPI_DeviceAuthInternalCountDevicesExecute_Call) RunAndReturn(run func(r client.ApiDeviceAuthInternalCountDevicesRequest) (*client.Count, *http.Response, error)) *MockDeviceAuthenticationInternalAPIAPI_DeviceAuthInternalCountDevicesExecute_Call {
	_c.Call.Return(run)
	return _c
}

// DeviceAuthInternalCreateTenant provides a mock function for the type MockDeviceAuthenticationInternalAPIAPI
func (_mock *MockDeviceAuthenticationInternalAPIAPI) DeviceAuthInternalCreateTenant(ctx context.Context) client.ApiDeviceAuthInternalCreateTenantRequest {
	ret := _mock.Called(ctx)

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

	var r0 client.ApiDeviceAuthInternalCreateTenantRequest
	if returnFunc, ok := ret.Get(0).(func(context.Context) client.ApiDeviceAuthInternalCreateTenantRequest); ok {
		r0 = returnFunc(ctx)
	} else {
		r0 = ret.Get(0).(client.ApiDeviceAuthInternalCreateTenantRequest)
	}
	return r0
}

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

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

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

func (_c *MockDeviceAuthenticationInternalAPIAPI_DeviceAuthInternalCreateTenant_Call) Return(apiDeviceAuthInternalCreateTenantRequest client.ApiDeviceAuthInternalCreateTenantRequest) *MockDeviceAuthenticationInternalAPIAPI_DeviceAuthInternalCreateTenant_Call {
	_c.Call.Return(apiDeviceAuthInternalCreateTenantRequest)
	return _c
}

func (_c *MockDeviceAuthenticationInternalAPIAPI_DeviceAuthInternalCreateTenant_Call) RunAndReturn(run func(ctx context.Context) client.ApiDeviceAuthInternalCreateTenantRequest) *MockDeviceAuthenticationInternalAPIAPI_DeviceAuthInternalCreateTenant_Call {
	_c.Call.Return(run)
	return _c
}

// DeviceAuthInternalCreateTenantExecute provides a mock function for the type MockDeviceAuthenticationInternalAPIAPI
func (_mock *MockDeviceAuthenticationInternalAPIAPI) DeviceAuthInternalCreateTenantExecute(r client.ApiDeviceAuthInternalCreateTenantRequest) (*http.Response, error) {
	ret := _mock.Called(r)

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

	var r0 *http.Response
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(client.ApiDeviceAuthInternalCreateTenantRequest) (*http.Response, error)); ok {
		return returnFunc(r)
	}
	if returnFunc, ok := ret.Get(0).(func(client.ApiDeviceAuthInternalCreateTenantRequest) *http.Response); ok {
		r0 = returnFunc(r)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*http.Response)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(client.ApiDeviceAuthInternalCreateTenantRequest) error); ok {
		r1 = returnFunc(r)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// DeviceAuthInternalCreateTenantExecute is a helper method to define mock.On call
//   - r client.ApiDeviceAuthInternalCreateTenantRequest
func (_e *MockDeviceAuthenticationInternalAPIAPI_Expecter) DeviceAuthInternalCreateTenantExecute(r interface{}) *MockDeviceAuthenticationInternalAPIAPI_DeviceAuthInternalCreateTenantExecute_Call {
	return &MockDeviceAuthenticationInternalAPIAPI_DeviceAuthInternalCreateTenantExecute_Call{Call: _e.mock.On("DeviceAuthInternalCreateTenantExecute", r)}
}

func (_c *MockDeviceAuthenticationInternalAPIAPI_DeviceAuthInternalCreateTenantExecute_Call) Run(run func(r client.ApiDeviceAuthInternalCreateTenantRequest)) *MockDeviceAuthenticationInternalAPIAPI_DeviceAuthInternalCreateTenantExecute_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 client.ApiDeviceAuthInternalCreateTenantRequest
		if args[0] != nil {
			arg0 = args[0].(client.ApiDeviceAuthInternalCreateTenantRequest)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *MockDeviceAuthenticationInternalAPIAPI_DeviceAuthInternalCreateTenantExecute_Call) Return(response *http.Response, err error) *MockDeviceAuthenticationInternalAPIAPI_DeviceAuthInternalCreateTenantExecute_Call {
	_c.Call.Return(response, err)
	return _c
}

func (_c *MockDeviceAuthenticationInternalAPIAPI_DeviceAuthInternalCreateTenantExecute_Call) RunAndReturn(run func(r client.ApiDeviceAuthInternalCreateTenantRequest) (*http.Response, error)) *MockDeviceAuthenticationInternalAPIAPI_DeviceAuthInternalCreateTenantExecute_Call {
	_c.Call.Return(run)
	return _c
}

// DeviceAuthInternalDeleteDevice provides a mock function for the type MockDeviceAuthenticationInternalAPIAPI
func (_mock *MockDeviceAuthenticationInternalAPIAPI) DeviceAuthInternalDeleteDevice(ctx context.Context, tid string, did string) client.ApiDeviceAuthInternalDeleteDeviceRequest {
	ret := _mock.Called(ctx, tid, did)

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

	var r0 client.ApiDeviceAuthInternalDeleteDeviceRequest
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string) client.ApiDeviceAuthInternalDeleteDeviceRequest); ok {
		r0 = returnFunc(ctx, tid, did)
	} else {
		r0 = ret.Get(0).(client.ApiDeviceAuthInternalDeleteDeviceRequest)
	}
	return r0
}

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

// DeviceAuthInternalDeleteDevice is a helper method to define mock.On call
//   - ctx context.Context
//   - tid string
//   - did string
func (_e *MockDeviceAuthenticationInternalAPIAPI_Expecter) DeviceAuthInternalDeleteDevice(ctx interface{}, tid interface{}, did interface{}) *MockDeviceAuthenticationInternalAPIAPI_DeviceAuthInternalDeleteDevice_Call {
	return &MockDeviceAuthenticationInternalAPIAPI_DeviceAuthInternalDeleteDevice_Call{Call: _e.mock.On("DeviceAuthInternalDeleteDevice", ctx, tid, did)}
}

func (_c *MockDeviceAuthenticationInternalAPIAPI_DeviceAuthInternalDeleteDevice_Call) Run(run func(ctx context.Context, tid string, did string)) *MockDeviceAuthenticationInternalAPIAPI_DeviceAuthInternalDeleteDevice_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)
		}
		run(
			arg0,
			arg1,
			arg2,
		)
	})
	return _c
}

func (_c *MockDeviceAuthenticationInternalAPIAPI_DeviceAuthInternalDeleteDevice_Call) Return(apiDeviceAuthInternalDeleteDeviceRequest client.ApiDeviceAuthInternalDeleteDeviceRequest) *MockDeviceAuthenticationInternalAPIAPI_DeviceAuthInternalDeleteDevice_Call {
	_c.Call.Return(apiDeviceAuthInternalDeleteDeviceRequest)
	return _c
}

func (_c *MockDeviceAuthenticationInternalAPIAPI_DeviceAuthInternalDeleteDevice_Call) RunAndReturn(run func(ctx context.Context, tid string, did string) client.ApiDeviceAuthInternalDeleteDeviceRequest) *MockDeviceAuthenticationInternalAPIAPI_DeviceAuthInternalDeleteDevice_Call {
	_c.Call.Return(run)
	return _c
}

// DeviceAuthInternalDeleteDeviceExecute provides a mock function for the type MockDeviceAuthenticationInternalAPIAPI
func (_mock *MockDeviceAuthenticationInternalAPIAPI) DeviceAuthInternalDeleteDeviceExecute(r client.ApiDeviceAuthInternalDeleteDeviceRequest) (*http.Response, error) {
	ret := _mock.Called(r)

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

	var r0 *http.Response
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(client.ApiDeviceAuthInternalDeleteDeviceRequest) (*http.Response, error)); ok {
		return returnFunc(r)
	}
	if returnFunc, ok := ret.Get(0).(func(client.ApiDeviceAuthInternalDeleteDeviceRequest) *http.Response); ok {
		r0 = returnFunc(r)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*http.Response)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(client.ApiDeviceAuthInternalDeleteDeviceRequest) error); ok {
		r1 = returnFunc(r)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// DeviceAuthInternalDeleteDeviceExecute is a helper method to define mock.On call
//   - r client.ApiDeviceAuthInternalDeleteDeviceRequest
func (_e *MockDeviceAuthenticationInternalAPIAPI_Expecter) DeviceAuthInternalDeleteDeviceExecute(r interface{}) *MockDeviceAuthenticationInternalAPIAPI_DeviceAuthInternalDeleteDeviceExecute_Call {
	return &MockDeviceAuthenticationInternalAPIAPI_DeviceAuthInternalDeleteDeviceExecute_Call{Call: _e.mock.On("DeviceAuthInternalDeleteDeviceExecute", r)}
}

func (_c *MockDeviceAuthenticationInternalAPIAPI_DeviceAuthInternalDeleteDeviceExecute_Call) Run(run func(r client.ApiDeviceAuthInternalDeleteDeviceRequest)) *MockDeviceAuthenticationInternalAPIAPI_DeviceAuthInternalDeleteDeviceExecute_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 client.ApiDeviceAuthInternalDeleteDeviceRequest
		if args[0] != nil {
			arg0 = args[0].(client.ApiDeviceAuthInternalDeleteDeviceRequest)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *MockDeviceAuthenticationInternalAPIAPI_DeviceAuthInternalDeleteDeviceExecute_Call) Return(response *http.Response, err error) *MockDeviceAuthenticationInternalAPIAPI_DeviceAuthInternalDeleteDeviceExecute_Call {
	_c.Call.Return(response, err)
	return _c
}

func (_c *MockDeviceAuthenticationInternalAPIAPI_DeviceAuthInternalDeleteDeviceExecute_Call) RunAndReturn(run func(r client.ApiDeviceAuthInternalDeleteDeviceRequest) (*http.Response, error)) *MockDeviceAuthenticationInternalAPIAPI_DeviceAuthInternalDeleteDeviceExecute_Call {
	_c.Call.Return(run)
	return _c
}

// DeviceAuthInternalDeviceStatus provides a mock function for the type MockDeviceAuthenticationInternalAPIAPI
func (_mock *MockDeviceAuthenticationInternalAPIAPI) DeviceAuthInternalDeviceStatus(ctx context.Context, tid string, did string) client.ApiDeviceAuthInternalDeviceStatusRequest {
	ret := _mock.Called(ctx, tid, did)

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

	var r0 client.ApiDeviceAuthInternalDeviceStatusRequest
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string) client.ApiDeviceAuthInternalDeviceStatusRequest); ok {
		r0 = returnFunc(ctx, tid, did)
	} else {
		r0 = ret.Get(0).(client.ApiDeviceAuthInternalDeviceStatusRequest)
	}
	return r0
}

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

// DeviceAuthInternalDeviceStatus is a helper method to define mock.On call
//   - ctx context.Context
//   - tid string
//   - did string
func (_e *MockDeviceAuthenticationInternalAPIAPI_Expecter) DeviceAuthInternalDeviceStatus(ctx interface{}, tid interface{}, did interface{}) *MockDeviceAuthenticationInternalAPIAPI_DeviceAuthInternalDeviceStatus_Call {
	return &MockDeviceAuthenticationInternalAPIAPI_DeviceAuthInternalDeviceStatus_Call{Call: _e.mock.On("DeviceAuthInternalDeviceStatus", ctx, tid, did)}
}

func (_c *MockDeviceAuthenticationInternalAPIAPI_DeviceAuthInternalDeviceStatus_Call) Run(run func(ctx context.Context, tid string, did string)) *MockDeviceAuthenticationInternalAPIAPI_DeviceAuthInternalDeviceStatus_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)
		}
		run(
			arg0,
			arg1,
			arg2,
		)
	})
	return _c
}

func (_c *MockDeviceAuthenticationInternalAPIAPI_DeviceAuthInternalDeviceStatus_Call) Return(apiDeviceAuthInternalDeviceStatusRequest client.ApiDeviceAuthInternalDeviceStatusRequest) *MockDeviceAuthenticationInternalAPIAPI_DeviceAuthInternalDeviceStatus_Call {
	_c.Call.Return(apiDeviceAuthInternalDeviceStatusRequest)
	return _c
}

func (_c *MockDeviceAuthenticationInternalAPIAPI_DeviceAuthInternalDeviceStatus_Call) RunAndReturn(run func(ctx context.Context, tid string, did string) client.ApiDeviceAuthInternalDeviceStatusRequest) *MockDeviceAuthenticationInternalAPIAPI_DeviceAuthInternalDeviceStatus_Call {
	_c.Call.Return(run)
	return _c
}

// DeviceAuthInternalDeviceStatusExecute provides a mock function for the type MockDeviceAuthenticationInternalAPIAPI
func (_mock *MockDeviceAuthenticationInternalAPIAPI) DeviceAuthInternalDeviceStatusExecute(r client.ApiDeviceAuthInternalDeviceStatusRequest) (*client.Status, *http.Response, error) {
	ret := _mock.Called(r)

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

	var r0 *client.Status
	var r1 *http.Response
	var r2 error
	if returnFunc, ok := ret.Get(0).(func(client.ApiDeviceAuthInternalDeviceStatusRequest) (*client.Status, *http.Response, error)); ok {
		return returnFunc(r)
	}
	if returnFunc, ok := ret.Get(0).(func(client.ApiDeviceAuthInternalDeviceStatusRequest) *client.Status); ok {
		r0 = returnFunc(r)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*client.Status)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(client.ApiDeviceAuthInternalDeviceStatusRequest) *http.Response); ok {
		r1 = returnFunc(r)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*http.Response)
		}
	}
	if returnFunc, ok := ret.Get(2).(func(client.ApiDeviceAuthInternalDeviceStatusRequest) error); ok {
		r2 = returnFunc(r)
	} else {
		r2 = ret.Error(2)
	}
	return r0, r1, r2
}

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

// DeviceAuthInternalDeviceStatusExecute is a helper method to define mock.On call
//   - r client.ApiDeviceAuthInternalDeviceStatusRequest
func (_e *MockDeviceAuthenticationInternalAPIAPI_Expecter) DeviceAuthInternalDeviceStatusExecute(r interface{}) *MockDeviceAuthenticationInternalAPIAPI_DeviceAuthInternalDeviceStatusExecute_Call {
	return &MockDeviceAuthenticationInternalAPIAPI_DeviceAuthInternalDeviceStatusExecute_Call{Call: _e.mock.On("DeviceAuthInternalDeviceStatusExecute", r)}
}

func (_c *MockDeviceAuthenticationInternalAPIAPI_DeviceAuthInternalDeviceStatusExecute_Call) Run(run func(r client.ApiDeviceAuthInternalDeviceStatusRequest)) *MockDeviceAuthenticationInternalAPIAPI_DeviceAuthInternalDeviceStatusExecute_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 client.ApiDeviceAuthInternalDeviceStatusRequest
		if args[0] != nil {
			arg0 = args[0].(client.ApiDeviceAuthInternalDeviceStatusRequest)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *MockDeviceAuthenticationInternalAPIAPI_DeviceAuthInternalDeviceStatusExecute_Call) Return(status *client.Status, response *http.Response, err error) *MockDeviceAuthenticationInternalAPIAPI_DeviceAuthInternalDeviceStatusExecute_Call {
	_c.Call.Return(status, response, err)
	return _c
}

func (_c *MockDeviceAuthenticationInternalAPIAPI_DeviceAuthInternalDeviceStatusExecute_Call) RunAndReturn(run func(r client.ApiDeviceAuthInternalDeviceStatusRequest) (*client.Status, *http.Response, error)) *MockDeviceAuthenticationInternalAPIAPI_DeviceAuthInternalDeviceStatusExecute_Call {
	_c.Call.Return(run)
	return _c
}

// DeviceAuthInternalGetDeviceLimit provides a mock function for the type MockDeviceAuthenticationInternalAPIAPI
func (_mock *MockDeviceAuthenticationInternalAPIAPI) DeviceAuthInternalGetDeviceLimit(ctx context.Context, tenantId string) client.ApiDeviceAuthInternalGetDeviceLimitRequest {
	ret := _mock.Called(ctx, tenantId)

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

	var r0 client.ApiDeviceAuthInternalGetDeviceLimitRequest
	if returnFunc, ok := ret.Get(0).(func(context.Context, string) client.ApiDeviceAuthInternalGetDeviceLimitRequest); ok {
		r0 = returnFunc(ctx, tenantId)
	} else {
		r0 = ret.Get(0).(client.ApiDeviceAuthInternalGetDeviceLimitRequest)
	}
	return r0
}

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

// DeviceAuthInternalGetDeviceLimit is a helper method to define mock.On call
//   - ctx context.Context
//   - tenantId string
func (_e *MockDeviceAuthenticationInternalAPIAPI_Expecter) DeviceAuthInternalGetDeviceLimit(ctx interface{}, tenantId interface{}) *MockDeviceAuthenticationInternalAPIAPI_DeviceAuthInternalGetDeviceLimit_Call {
	return &MockDeviceAuthenticationInternalAPIAPI_DeviceAuthInternalGetDeviceLimit_Call{Call: _e.mock.On("DeviceAuthInternalGetDeviceLimit", ctx, tenantId)}
}

func (_c *MockDeviceAuthenticationInternalAPIAPI_DeviceAuthInternalGetDeviceLimit_Call) Run(run func(ctx context.Context, tenantId string)) *MockDeviceAuthenticationInternalAPIAPI_DeviceAuthInternalGetDeviceLimit_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 *MockDeviceAuthenticationInternalAPIAPI_DeviceAuthInternalGetDeviceLimit_Call) Return(apiDeviceAuthInternalGetDeviceLimitRequest client.ApiDeviceAuthInternalGetDeviceLimitRequest) *MockDeviceAuthenticationInternalAPIAPI_DeviceAuthInternalGetDeviceLimit_Call {
	_c.Call.Return(apiDeviceAuthInternalGetDeviceLimitRequest)
	return _c
}

func (_c *MockDeviceAuthenticationInternalAPIAPI_DeviceAuthInternalGetDeviceLimit_Call) RunAndReturn(run func(ctx context.Context, tenantId string) client.ApiDeviceAuthInternalGetDeviceLimitRequest) *MockDeviceAuthenticationInternalAPIAPI_DeviceAuthInternalGetDeviceLimit_Call {
	_c.Call.Return(run)
	return _c
}

// DeviceAuthInternalGetDeviceLimitExecute provides a mock function for the type MockDeviceAuthenticationInternalAPIAPI
func (_mock *MockDeviceAuthenticationInternalAPIAPI) DeviceAuthInternalGetDeviceLimitExecute(r client.ApiDeviceAuthInternalGetDeviceLimitRequest) (*client.Limit, *http.Response, error) {
	ret := _mock.Called(r)

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

	var r0 *client.Limit
	var r1 *http.Response
	var r2 error
	if returnFunc, ok := ret.Get(0).(func(client.ApiDeviceAuthInternalGetDeviceLimitRequest) (*client.Limit, *http.Response, error)); ok {
		return returnFunc(r)
	}
	if returnFunc, ok := ret.Get(0).(func(client.ApiDeviceAuthInternalGetDeviceLimitRequest) *client.Limit); ok {
		r0 = returnFunc(r)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*client.Limit)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(client.ApiDeviceAuthInternalGetDeviceLimitRequest) *http.Response); ok {
		r1 = returnFunc(r)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*http.Response)
		}
	}
	if returnFunc, ok := ret.Get(2).(func(client.ApiDeviceAuthInternalGetDeviceLimitRequest) error); ok {
		r2 = returnFunc(r)
	} else {
		r2 = ret.Error(2)
	}
	return r0, r1, r2
}

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

// DeviceAuthInternalGetDeviceLimitExecute is a helper method to define mock.On call
//   - r client.ApiDeviceAuthInternalGetDeviceLimitRequest
func (_e *MockDeviceAuthenticationInternalAPIAPI_Expecter) DeviceAuthInternalGetDeviceLimitExecute(r interface{}) *MockDeviceAuthenticationInternalAPIAPI_DeviceAuthInternalGetDeviceLimitExecute_Call {
	return &MockDeviceAuthenticationInternalAPIAPI_DeviceAuthInternalGetDeviceLimitExecute_Call{Call: _e.mock.On("DeviceAuthInternalGetDeviceLimitExecute", r)}
}

func (_c *MockDeviceAuthenticationInternalAPIAPI_DeviceAuthInternalGetDeviceLimitExecute_Call) Run(run func(r client.ApiDeviceAuthInternalGetDeviceLimitRequest)) *MockDeviceAuthenticationInternalAPIAPI_DeviceAuthInternalGetDeviceLimitExecute_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 client.ApiDeviceAuthInternalGetDeviceLimitRequest
		if args[0] != nil {
			arg0 = args[0].(client.ApiDeviceAuthInternalGetDeviceLimitRequest)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *MockDeviceAuthenticationInternalAPIAPI_DeviceAuthInternalGetDeviceLimitExecute_Call) Return(limit *client.Limit, response *http.Response, err error) *MockDeviceAuthenticationInternalAPIAPI_DeviceAuthInternalGetDeviceLimitExecute_Call {
	_c.Call.Return(limit, response, err)
	return _c
}

func (_c *MockDeviceAuthenticationInternalAPIAPI_DeviceAuthInternalGetDeviceLimitExecute_Call) RunAndReturn(run func(r client.ApiDeviceAuthInternalGetDeviceLimitRequest) (*client.Limit, *http.Response, error)) *MockDeviceAuthenticationInternalAPIAPI_DeviceAuthInternalGetDeviceLimitExecute_Call {
	_c.Call.Return(run)
	return _c
}

// DeviceAuthInternalListDevices provides a mock function for the type MockDeviceAuthenticationInternalAPIAPI
func (_mock *MockDeviceAuthenticationInternalAPIAPI) DeviceAuthInternalListDevices(ctx context.Context, tid string) client.ApiDeviceAuthInternalListDevicesRequest {
	ret := _mock.Called(ctx, tid)

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

	var r0 client.ApiDeviceAuthInternalListDevicesRequest
	if returnFunc, ok := ret.Get(0).(func(context.Context, string) client.ApiDeviceAuthInternalListDevicesRequest); ok {
		r0 = returnFunc(ctx, tid)
	} else {
		r0 = ret.Get(0).(client.ApiDeviceAuthInternalListDevicesRequest)
	}
	return r0
}

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

// DeviceAuthInternalListDevices is a helper method to define mock.On call
//   - ctx context.Context
//   - tid string
func (_e *MockDeviceAuthenticationInternalAPIAPI_Expecter) DeviceAuthInternalListDevices(ctx interface{}, tid interface{}) *MockDeviceAuthenticationInternalAPIAPI_DeviceAuthInternalListDevices_Call {
	return &MockDeviceAuthenticationInternalAPIAPI_DeviceAuthInternalListDevices_Call{Call: _e.mock.On("DeviceAuthInternalListDevices", ctx, tid)}
}

func (_c *MockDeviceAuthenticationInternalAPIAPI_DeviceAuthInternalListDevices_Call) Run(run func(ctx context.Context, tid string)) *MockDeviceAuthenticationInternalAPIAPI_DeviceAuthInternalListDevices_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 *MockDeviceAuthenticationInternalAPIAPI_DeviceAuthInternalListDevices_Call) Return(apiDeviceAuthInternalListDevicesRequest client.ApiDeviceAuthInternalListDevicesRequest) *MockDeviceAuthenticationInternalAPIAPI_DeviceAuthInternalListDevices_Call {
	_c.Call.Return(apiDeviceAuthInternalListDevicesRequest)
	return _c
}

func (_c *MockDeviceAuthenticationInternalAPIAPI_DeviceAuthInternalListDevices_Call) RunAndReturn(run func(ctx context.Context, tid string) client.ApiDeviceAuthInternalListDevicesRequest) *MockDeviceAuthenticationInternalAPIAPI_DeviceAuthInternalListDevices_Call {
	_c.Call.Return(run)
	return _c
}

// DeviceAuthInternalListDevicesExecute provides a mock function for the type MockDeviceAuthenticationInternalAPIAPI
func (_mock *MockDeviceAuthenticationInternalAPIAPI) DeviceAuthInternalListDevicesExecute(r client.ApiDeviceAuthInternalListDevicesRequest) ([]client.Device, *http.Response, error) {
	ret := _mock.Called(r)

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

	var r0 []client.Device
	var r1 *http.Response
	var r2 error
	if returnFunc, ok := ret.Get(0).(func(client.ApiDeviceAuthInternalListDevicesRequest) ([]client.Device, *http.Response, error)); ok {
		return returnFunc(r)
	}
	if returnFunc, ok := ret.Get(0).(func(client.ApiDeviceAuthInternalListDevicesRequest) []client.Device); ok {
		r0 = returnFunc(r)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]client.Device)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(client.ApiDeviceAuthInternalListDevicesRequest) *http.Response); ok {
		r1 = returnFunc(r)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*http.Response)
		}
	}
	if returnFunc, ok := ret.Get(2).(func(client.ApiDeviceAuthInternalListDevicesRequest) error); ok {
		r2 = returnFunc(r)
	} else {
		r2 = ret.Error(2)
	}
	return r0, r1, r2
}

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

// DeviceAuthInternalListDevicesExecute is a helper method to define mock.On call
//   - r client.ApiDeviceAuthInternalListDevicesRequest
func (_e *MockDeviceAuthenticationInternalAPIAPI_Expecter) DeviceAuthInternalListDevicesExecute(r interface{}) *MockDeviceAuthenticationInternalAPIAPI_DeviceAuthInternalListDevicesExecute_Call {
	return &MockDeviceAuthenticationInternalAPIAPI_DeviceAuthInternalListDevicesExecute_Call{Call: _e.mock.On("DeviceAuthInternalListDevicesExecute", r)}
}

func (_c *MockDeviceAuthenticationInternalAPIAPI_DeviceAuthInternalListDevicesExecute_Call) Run(run func(r client.ApiDeviceAuthInternalListDevicesRequest)) *MockDeviceAuthenticationInternalAPIAPI_DeviceAuthInternalListDevicesExecute_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 client.ApiDeviceAuthInternalListDevicesRequest
		if args[0] != nil {
			arg0 = args[0].(client.ApiDeviceAuthInternalListDevicesRequest)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *MockDeviceAuthenticationInternalAPIAPI_DeviceAuthInternalListDevicesExecute_Call) Return(devices []client.Device, response *http.Response, err error) *MockDeviceAuthenticationInternalAPIAPI_DeviceAuthInternalListDevicesExecute_Call {
	_c.Call.Return(devices, response, err)
	return _c
}

func (_c *MockDeviceAuthenticationInternalAPIAPI_DeviceAuthInternalListDevicesExecute_Call) RunAndReturn(run func(r client.ApiDeviceAuthInternalListDevicesRequest) ([]client.Device, *http.Response, error)) *MockDeviceAuthenticationInternalAPIAPI_DeviceAuthInternalListDevicesExecute_Call {
	_c.Call.Return(run)
	return _c
}

// DeviceAuthInternalRevokeDeviceTokens provides a mock function for the type MockDeviceAuthenticationInternalAPIAPI
func (_mock *MockDeviceAuthenticationInternalAPIAPI) DeviceAuthInternalRevokeDeviceTokens(ctx context.Context) client.ApiDeviceAuthInternalRevokeDeviceTokensRequest {
	ret := _mock.Called(ctx)

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

	var r0 client.ApiDeviceAuthInternalRevokeDeviceTokensRequest
	if returnFunc, ok := ret.Get(0).(func(context.Context) client.ApiDeviceAuthInternalRevokeDeviceTokensRequest); ok {
		r0 = returnFunc(ctx)
	} else {
		r0 = ret.Get(0).(client.ApiDeviceAuthInternalRevokeDeviceTokensRequest)
	}
	return r0
}

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

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

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

func (_c *MockDeviceAuthenticationInternalAPIAPI_DeviceAuthInternalRevokeDeviceTokens_Call) Return(apiDeviceAuthInternalRevokeDeviceTokensRequest client.ApiDeviceAuthInternalRevokeDeviceTokensRequest) *MockDeviceAuthenticationInternalAPIAPI_DeviceAuthInternalRevokeDeviceTokens_Call {
	_c.Call.Return(apiDeviceAuthInternalRevokeDeviceTokensRequest)
	return _c
}

func (_c *MockDeviceAuthenticationInternalAPIAPI_DeviceAuthInternalRevokeDeviceTokens_Call) RunAndReturn(run func(ctx context.Context) client.ApiDeviceAuthInternalRevokeDeviceTokensRequest) *MockDeviceAuthenticationInternalAPIAPI_DeviceAuthInternalRevokeDeviceTokens_Call {
	_c.Call.Return(run)
	return _c
}

// DeviceAuthInternalRevokeDeviceTokensExecute provides a mock function for the type MockDeviceAuthenticationInternalAPIAPI
func (_mock *MockDeviceAuthenticationInternalAPIAPI) DeviceAuthInternalRevokeDeviceTokensExecute(r client.ApiDeviceAuthInternalRevokeDeviceTokensRequest) (*http.Response, error) {
	ret := _mock.Called(r)

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

	var r0 *http.Response
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(client.ApiDeviceAuthInternalRevokeDeviceTokensRequest) (*http.Response, error)); ok {
		return returnFunc(r)
	}
	if returnFunc, ok := ret.Get(0).(func(client.ApiDeviceAuthInternalRevokeDeviceTokensRequest) *http.Response); ok {
		r0 = returnFunc(r)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*http.Response)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(client.ApiDeviceAuthInternalRevokeDeviceTokensRequest) error); ok {
		r1 = returnFunc(r)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// DeviceAuthInternalRevokeDeviceTokensExecute is a helper method to define mock.On call
//   - r client.ApiDeviceAuthInternalRevokeDeviceTokensRequest
func (_e *MockDeviceAuthenticationInternalAPIAPI_Expecter) DeviceAuthInternalRevokeDeviceTokensExecute(r interface{}) *MockDeviceAuthenticationInternalAPIAPI_DeviceAuthInternalRevokeDeviceTokensExecute_Call {
	return &MockDeviceAuthenticationInternalAPIAPI_DeviceAuthInternalRevokeDeviceTokensExecute_Call{Call: _e.mock.On("DeviceAuthInternalRevokeDeviceTokensExecute", r)}
}

func (_c *MockDeviceAuthenticationInternalAPIAPI_DeviceAuthInternalRevokeDeviceTokensExecute_Call) Run(run func(r client.ApiDeviceAuthInternalRevokeDeviceTokensRequest)) *MockDeviceAuthenticationInternalAPIAPI_DeviceAuthInternalRevokeDeviceTokensExecute_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 client.ApiDeviceAuthInternalRevokeDeviceTokensRequest
		if args[0] != nil {
			arg0 = args[0].(client.ApiDeviceAuthInternalRevokeDeviceTokensRequest)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *MockDeviceAuthenticationInternalAPIAPI_DeviceAuthInternalRevokeDeviceTokensExecute_Call) Return(response *http.Response, err error) *MockDeviceAuthenticationInternalAPIAPI_DeviceAuthInternalRevokeDeviceTokensExecute_Call {
	_c.Call.Return(response, err)
	return _c
}

func (_c *MockDeviceAuthenticationInternalAPIAPI_DeviceAuthInternalRevokeDeviceTokensExecute_Call) RunAndReturn(run func(r client.ApiDeviceAuthInternalRevokeDeviceTokensRequest) (*http.Response, error)) *MockDeviceAuthenticationInternalAPIAPI_DeviceAuthInternalRevokeDeviceTokensExecute_Call {
	_c.Call.Return(run)
	return _c
}

// DeviceAuthInternalSetExternalIdentity provides a mock function for the type MockDeviceAuthenticationInternalAPIAPI
func (_mock *MockDeviceAuthenticationInternalAPIAPI) DeviceAuthInternalSetExternalIdentity(ctx context.Context, tid string, did string) client.ApiDeviceAuthInternalSetExternalIdentityRequest {
	ret := _mock.Called(ctx, tid, did)

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

	var r0 client.ApiDeviceAuthInternalSetExternalIdentityRequest
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string) client.ApiDeviceAuthInternalSetExternalIdentityRequest); ok {
		r0 = returnFunc(ctx, tid, did)
	} else {
		r0 = ret.Get(0).(client.ApiDeviceAuthInternalSetExternalIdentityRequest)
	}
	return r0
}

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

// DeviceAuthInternalSetExternalIdentity is a helper method to define mock.On call
//   - ctx context.Context
//   - tid string
//   - did string
func (_e *MockDeviceAuthenticationInternalAPIAPI_Expecter) DeviceAuthInternalSetExternalIdentity(ctx interface{}, tid interface{}, did interface{}) *MockDeviceAuthenticationInternalAPIAPI_DeviceAuthInternalSetExternalIdentity_Call {
	return &MockDeviceAuthenticationInternalAPIAPI_DeviceAuthInternalSetExternalIdentity_Call{Call: _e.mock.On("DeviceAuthInternalSetExternalIdentity", ctx, tid, did)}
}

func (_c *MockDeviceAuthenticationInternalAPIAPI_DeviceAuthInternalSetExternalIdentity_Call) Run(run func(ctx context.Context, tid string, did string)) *MockDeviceAuthenticationInternalAPIAPI_DeviceAuthInternalSetExternalIdentity_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)
		}
		run(
			arg0,
			arg1,
			arg2,
		)
	})
	return _c
}

func (_c *MockDeviceAuthenticationInternalAPIAPI_DeviceAuthInternalSetExternalIdentity_Call) Return(apiDeviceAuthInternalSetExternalIdentityRequest client.ApiDeviceAuthInternalSetExternalIdentityRequest) *MockDeviceAuthenticationInternalAPIAPI_DeviceAuthInternalSetExternalIdentity_Call {
	_c.Call.Return(apiDeviceAuthInternalSetExternalIdentityRequest)
	return _c
}

func (_c *MockDeviceAuthenticationInternalAPIAPI_DeviceAuthInternalSetExternalIdentity_Call) RunAndReturn(run func(ctx context.Context, tid string, did string) client.ApiDeviceAuthInternalSetExternalIdentityRequest) *MockDeviceAuthenticationInternalAPIAPI_DeviceAuthInternalSetExternalIdentity_Call {
	_c.Call.Return(run)
	return _c
}

// DeviceAuthInternalSetExternalIdentityExecute provides a mock function for the type MockDeviceAuthenticationInternalAPIAPI
func (_mock *MockDeviceAuthenticationInternalAPIAPI) DeviceAuthInternalSetExternalIdentityExecute(r client.ApiDeviceAuthInternalSetExternalIdentityRequest) (*http.Response, error) {
	ret := _mock.Called(r)

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

	var r0 *http.Response
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(client.ApiDeviceAuthInternalSetExternalIdentityRequest) (*http.Response, error)); ok {
		return returnFunc(r)
	}
	if returnFunc, ok := ret.Get(0).(func(client.ApiDeviceAuthInternalSetExternalIdentityRequest) *http.Response); ok {
		r0 = returnFunc(r)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*http.Response)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(client.ApiDeviceAuthInternalSetExternalIdentityRequest) error); ok {
		r1 = returnFunc(r)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// DeviceAuthInternalSetExternalIdentityExecute is a helper method to define mock.On call
//   - r client.ApiDeviceAuthInternalSetExternalIdentityRequest
func (_e *MockDeviceAuthenticationInternalAPIAPI_Expecter) DeviceAuthInternalSetExternalIdentityExecute(r interface{}) *MockDeviceAuthenticationInternalAPIAPI_DeviceAuthInternalSetExternalIdentityExecute_Call {
	return &MockDeviceAuthenticationInternalAPIAPI_DeviceAuthInternalSetExternalIdentityExecute_Call{Call: _e.mock.On("DeviceAuthInternalSetExternalIdentityExecute", r)}
}

func (_c *MockDeviceAuthenticationInternalAPIAPI_DeviceAuthInternalSetExternalIdentityExecute_Call) Run(run func(r client.ApiDeviceAuthInternalSetExternalIdentityRequest)) *MockDeviceAuthenticationInternalAPIAPI_DeviceAuthInternalSetExternalIdentityExecute_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 client.ApiDeviceAuthInternalSetExternalIdentityRequest
		if args[0] != nil {
			arg0 = args[0].(client.ApiDeviceAuthInternalSetExternalIdentityRequest)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *MockDeviceAuthenticationInternalAPIAPI_DeviceAuthInternalSetExternalIdentityExecute_Call) Return(response *http.Response, err error) *MockDeviceAuthenticationInternalAPIAPI_DeviceAuthInternalSetExternalIdentityExecute_Call {
	_c.Call.Return(response, err)
	return _c
}

func (_c *MockDeviceAuthenticationInternalAPIAPI_DeviceAuthInternalSetExternalIdentityExecute_Call) RunAndReturn(run func(r client.ApiDeviceAuthInternalSetExternalIdentityRequest) (*http.Response, error)) *MockDeviceAuthenticationInternalAPIAPI_DeviceAuthInternalSetExternalIdentityExecute_Call {
	_c.Call.Return(run)
	return _c
}

// DeviceAuthInternalUpdateDeviceLimit provides a mock function for the type MockDeviceAuthenticationInternalAPIAPI
func (_mock *MockDeviceAuthenticationInternalAPIAPI) DeviceAuthInternalUpdateDeviceLimit(ctx context.Context, tenantId string) client.ApiDeviceAuthInternalUpdateDeviceLimitRequest {
	ret := _mock.Called(ctx, tenantId)

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

	var r0 client.ApiDeviceAuthInternalUpdateDeviceLimitRequest
	if returnFunc, ok := ret.Get(0).(func(context.Context, string) client.ApiDeviceAuthInternalUpdateDeviceLimitRequest); ok {
		r0 = returnFunc(ctx, tenantId)
	} else {
		r0 = ret.Get(0).(client.ApiDeviceAuthInternalUpdateDeviceLimitRequest)
	}
	return r0
}

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

// DeviceAuthInternalUpdateDeviceLimit is a helper method to define mock.On call
//   - ctx context.Context
//   - tenantId string
func (_e *MockDeviceAuthenticationInternalAPIAPI_Expecter) DeviceAuthInternalUpdateDeviceLimit(ctx interface{}, tenantId interface{}) *MockDeviceAuthenticationInternalAPIAPI_DeviceAuthInternalUpdateDeviceLimit_Call {
	return &MockDeviceAuthenticationInternalAPIAPI_DeviceAuthInternalUpdateDeviceLimit_Call{Call: _e.mock.On("DeviceAuthInternalUpdateDeviceLimit", ctx, tenantId)}
}

func (_c *MockDeviceAuthenticationInternalAPIAPI_DeviceAuthInternalUpdateDeviceLimit_Call) Run(run func(ctx context.Context, tenantId string)) *MockDeviceAuthenticationInternalAPIAPI_DeviceAuthInternalUpdateDeviceLimit_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 *MockDeviceAuthenticationInternalAPIAPI_DeviceAuthInternalUpdateDeviceLimit_Call) Return(apiDeviceAuthInternalUpdateDeviceLimitRequest client.ApiDeviceAuthInternalUpdateDeviceLimitRequest) *MockDeviceAuthenticationInternalAPIAPI_DeviceAuthInternalUpdateDeviceLimit_Call {
	_c.Call.Return(apiDeviceAuthInternalUpdateDeviceLimitRequest)
	return _c
}

func (_c *MockDeviceAuthenticationInternalAPIAPI_DeviceAuthInternalUpdateDeviceLimit_Call) RunAndReturn(run func(ctx context.Context, tenantId string) client.ApiDeviceAuthInternalUpdateDeviceLimitRequest) *MockDeviceAuthenticationInternalAPIAPI_DeviceAuthInternalUpdateDeviceLimit_Call {
	_c.Call.Return(run)
	return _c
}

// DeviceAuthInternalUpdateDeviceLimitExecute provides a mock function for the type MockDeviceAuthenticationInternalAPIAPI
func (_mock *MockDeviceAuthenticationInternalAPIAPI) DeviceAuthInternalUpdateDeviceLimitExecute(r client.ApiDeviceAuthInternalUpdateDeviceLimitRequest) (*http.Response, error) {
	ret := _mock.Called(r)

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

	var r0 *http.Response
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(client.ApiDeviceAuthInternalUpdateDeviceLimitRequest) (*http.Response, error)); ok {
		return returnFunc(r)
	}
	if returnFunc, ok := ret.Get(0).(func(client.ApiDeviceAuthInternalUpdateDeviceLimitRequest) *http.Response); ok {
		r0 = returnFunc(r)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*http.Response)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(client.ApiDeviceAuthInternalUpdateDeviceLimitRequest) error); ok {
		r1 = returnFunc(r)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// DeviceAuthInternalUpdateDeviceLimitExecute is a helper method to define mock.On call
//   - r client.ApiDeviceAuthInternalUpdateDeviceLimitRequest
func (_e *MockDeviceAuthenticationInternalAPIAPI_Expecter) DeviceAuthInternalUpdateDeviceLimitExecute(r interface{}) *MockDeviceAuthenticationInternalAPIAPI_DeviceAuthInternalUpdateDeviceLimitExecute_Call {
	return &MockDeviceAuthenticationInternalAPIAPI_DeviceAuthInternalUpdateDeviceLimitExecute_Call{Call: _e.mock.On("DeviceAuthInternalUpdateDeviceLimitExecute", r)}
}

func (_c *MockDeviceAuthenticationInternalAPIAPI_DeviceAuthInternalUpdateDeviceLimitExecute_Call) Run(run func(r client.ApiDeviceAuthInternalUpdateDeviceLimitRequest)) *MockDeviceAuthenticationInternalAPIAPI_DeviceAuthInternalUpdateDeviceLimitExecute_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 client.ApiDeviceAuthInternalUpdateDeviceLimitRequest
		if args[0] != nil {
			arg0 = args[0].(client.ApiDeviceAuthInternalUpdateDeviceLimitRequest)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *MockDeviceAuthenticationInternalAPIAPI_DeviceAuthInternalUpdateDeviceLimitExecute_Call) Return(response *http.Response, err error) *MockDeviceAuthenticationInternalAPIAPI_DeviceAuthInternalUpdateDeviceLimitExecute_Call {
	_c.Call.Return(response, err)
	return _c
}

func (_c *MockDeviceAuthenticationInternalAPIAPI_DeviceAuthInternalUpdateDeviceLimitExecute_Call) RunAndReturn(run func(r client.ApiDeviceAuthInternalUpdateDeviceLimitRequest) (*http.Response, error)) *MockDeviceAuthenticationInternalAPIAPI_DeviceAuthInternalUpdateDeviceLimitExecute_Call {
	_c.Call.Return(run)
	return _c
}

// DeviceAuthInternalVerifyJWT provides a mock function for the type MockDeviceAuthenticationInternalAPIAPI
func (_mock *MockDeviceAuthenticationInternalAPIAPI) DeviceAuthInternalVerifyJWT(ctx context.Context) client.ApiDeviceAuthInternalVerifyJWTRequest {
	ret := _mock.Called(ctx)

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

	var r0 client.ApiDeviceAuthInternalVerifyJWTRequest
	if returnFunc, ok := ret.Get(0).(func(context.Context) client.ApiDeviceAuthInternalVerifyJWTRequest); ok {
		r0 = returnFunc(ctx)
	} else {
		r0 = ret.Get(0).(client.ApiDeviceAuthInternalVerifyJWTRequest)
	}
	return r0
}

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

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

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

func (_c *MockDeviceAuthenticationInternalAPIAPI_DeviceAuthInternalVerifyJWT_Call) Return(apiDeviceAuthInternalVerifyJWTRequest client.ApiDeviceAuthInternalVerifyJWTRequest) *MockDeviceAuthenticationInternalAPIAPI_DeviceAuthInternalVerifyJWT_Call {
	_c.Call.Return(apiDeviceAuthInternalVerifyJWTRequest)
	return _c
}

func (_c *MockDeviceAuthenticationInternalAPIAPI_DeviceAuthInternalVerifyJWT_Call) RunAndReturn(run func(ctx context.Context) client.ApiDeviceAuthInternalVerifyJWTRequest) *MockDeviceAuthenticationInternalAPIAPI_DeviceAuthInternalVerifyJWT_Call {
	_c.Call.Return(run)
	return _c
}

// DeviceAuthInternalVerifyJWTExecute provides a mock function for the type MockDeviceAuthenticationInternalAPIAPI
func (_mock *MockDeviceAuthenticationInternalAPIAPI) DeviceAuthInternalVerifyJWTExecute(r client.ApiDeviceAuthInternalVerifyJWTRequest) (*http.Response, error) {
	ret := _mock.Called(r)

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

	var r0 *http.Response
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(client.ApiDeviceAuthInternalVerifyJWTRequest) (*http.Response, error)); ok {
		return returnFunc(r)
	}
	if returnFunc, ok := ret.Get(0).(func(client.ApiDeviceAuthInternalVerifyJWTRequest) *http.Response); ok {
		r0 = returnFunc(r)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*http.Response)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(client.ApiDeviceAuthInternalVerifyJWTRequest) error); ok {
		r1 = returnFunc(r)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// DeviceAuthInternalVerifyJWTExecute is a helper method to define mock.On call
//   - r client.ApiDeviceAuthInternalVerifyJWTRequest
func (_e *MockDeviceAuthenticationInternalAPIAPI_Expecter) DeviceAuthInternalVerifyJWTExecute(r interface{}) *MockDeviceAuthenticationInternalAPIAPI_DeviceAuthInternalVerifyJWTExecute_Call {
	return &MockDeviceAuthenticationInternalAPIAPI_DeviceAuthInternalVerifyJWTExecute_Call{Call: _e.mock.On("DeviceAuthInternalVerifyJWTExecute", r)}
}

func (_c *MockDeviceAuthenticationInternalAPIAPI_DeviceAuthInternalVerifyJWTExecute_Call) Run(run func(r client.ApiDeviceAuthInternalVerifyJWTRequest)) *MockDeviceAuthenticationInternalAPIAPI_DeviceAuthInternalVerifyJWTExecute_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 client.ApiDeviceAuthInternalVerifyJWTRequest
		if args[0] != nil {
			arg0 = args[0].(client.ApiDeviceAuthInternalVerifyJWTRequest)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *MockDeviceAuthenticationInternalAPIAPI_DeviceAuthInternalVerifyJWTExecute_Call) Return(response *http.Response, err error) *MockDeviceAuthenticationInternalAPIAPI_DeviceAuthInternalVerifyJWTExecute_Call {
	_c.Call.Return(response, err)
	return _c
}

func (_c *MockDeviceAuthenticationInternalAPIAPI_DeviceAuthInternalVerifyJWTExecute_Call) RunAndReturn(run func(r client.ApiDeviceAuthInternalVerifyJWTRequest) (*http.Response, error)) *MockDeviceAuthenticationInternalAPIAPI_DeviceAuthInternalVerifyJWTExecute_Call {
	_c.Call.Return(run)
	return _c
}

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

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

	return mock
}

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

type MockDeviceAuthenticationManagementAPIAPI_Expecter struct {
	mock *mock.Mock
}

func (_m *MockDeviceAuthenticationManagementAPIAPI) EXPECT() *MockDeviceAuthenticationManagementAPIAPI_Expecter {
	return &MockDeviceAuthenticationManagementAPIAPI_Expecter{mock: &_m.Mock}
}

// DeviceAuthManagementCountDevices provides a mock function for the type MockDeviceAuthenticationManagementAPIAPI
func (_mock *MockDeviceAuthenticationManagementAPIAPI) DeviceAuthManagementCountDevices(ctx context.Context) client.ApiDeviceAuthManagementCountDevicesRequest {
	ret := _mock.Called(ctx)

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

	var r0 client.ApiDeviceAuthManagementCountDevicesRequest
	if returnFunc, ok := ret.Get(0).(func(context.Context) client.ApiDeviceAuthManagementCountDevicesRequest); ok {
		r0 = returnFunc(ctx)
	} else {
		r0 = ret.Get(0).(client.ApiDeviceAuthManagementCountDevicesRequest)
	}
	return r0
}

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

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

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

func (_c *MockDeviceAuthenticationManagementAPIAPI_DeviceAuthManagementCountDevices_Call) Return(apiDeviceAuthManagementCountDevicesRequest client.ApiDeviceAuthManagementCountDevicesRequest) *MockDeviceAuthenticationManagementAPIAPI_DeviceAuthManagementCountDevices_Call {
	_c.Call.Return(apiDeviceAuthManagementCountDevicesRequest)
	return _c
}

func (_c *MockDeviceAuthenticationManagementAPIAPI_DeviceAuthManagementCountDevices_Call) RunAndReturn(run func(ctx context.Context) client.ApiDeviceAuthManagementCountDevicesRequest) *MockDeviceAuthenticationManagementAPIAPI_DeviceAuthManagementCountDevices_Call {
	_c.Call.Return(run)
	return _c
}

// DeviceAuthManagementCountDevicesExecute provides a mock function for the type MockDeviceAuthenticationManagementAPIAPI
func (_mock *MockDeviceAuthenticationManagementAPIAPI) DeviceAuthManagementCountDevicesExecute(r client.ApiDeviceAuthManagementCountDevicesRequest) (*client.Count, *http.Response, error) {
	ret := _mock.Called(r)

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

	var r0 *client.Count
	var r1 *http.Response
	var r2 error
	if returnFunc, ok := ret.Get(0).(func(client.ApiDeviceAuthManagementCountDevicesRequest) (*client.Count, *http.Response, error)); ok {
		return returnFunc(r)
	}
	if returnFunc, ok := ret.Get(0).(func(client.ApiDeviceAuthManagementCountDevicesRequest) *client.Count); ok {
		r0 = returnFunc(r)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*client.Count)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(client.ApiDeviceAuthManagementCountDevicesRequest) *http.Response); ok {
		r1 = returnFunc(r)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*http.Response)
		}
	}
	if returnFunc, ok := ret.Get(2).(func(client.ApiDeviceAuthManagementCountDevicesRequest) error); ok {
		r2 = returnFunc(r)
	} else {
		r2 = ret.Error(2)
	}
	return r0, r1, r2
}

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

// DeviceAuthManagementCountDevicesExecute is a helper method to define mock.On call
//   - r client.ApiDeviceAuthManagementCountDevicesRequest
func (_e *MockDeviceAuthenticationManagementAPIAPI_Expecter) DeviceAuthManagementCountDevicesExecute(r interface{}) *MockDeviceAuthenticationManagementAPIAPI_DeviceAuthManagementCountDevicesExecute_Call {
	return &MockDeviceAuthenticationManagementAPIAPI_DeviceAuthManagementCountDevicesExecute_Call{Call: _e.mock.On("DeviceAuthManagementCountDevicesExecute", r)}
}

func (_c *MockDeviceAuthenticationManagementAPIAPI_DeviceAuthManagementCountDevicesExecute_Call) Run(run func(r client.ApiDeviceAuthManagementCountDevicesRequest)) *MockDeviceAuthenticationManagementAPIAPI_DeviceAuthManagementCountDevicesExecute_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 client.ApiDeviceAuthManagementCountDevicesRequest
		if args[0] != nil {
			arg0 = args[0].(client.ApiDeviceAuthManagementCountDevicesRequest)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *MockDeviceAuthenticationManagementAPIAPI_DeviceAuthManagementCountDevicesExecute_Call) Return(count *client.Count, response *http.Response, err error) *MockDeviceAuthenticationManagementAPIAPI_DeviceAuthManagementCountDevicesExecute_Call {
	_c.Call.Return(count, response, err)
	return _c
}

func (_c *MockDeviceAuthenticationManagementAPIAPI_DeviceAuthManagementCountDevicesExecute_Call) RunAndReturn(run func(r client.ApiDeviceAuthManagementCountDevicesRequest) (*client.Count, *http.Response, error)) *MockDeviceAuthenticationManagementAPIAPI_DeviceAuthManagementCountDevicesExecute_Call {
	_c.Call.Return(run)
	return _c
}

// DeviceAuthManagementDecommissionDevice provides a mock function for the type MockDeviceAuthenticationManagementAPIAPI
func (_mock *MockDeviceAuthenticationManagementAPIAPI) DeviceAuthManagementDecommissionDevice(ctx context.Context, id string) client.ApiDeviceAuthManagementDecommissionDeviceRequest {
	ret := _mock.Called(ctx, id)

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

	var r0 client.ApiDeviceAuthManagementDecommissionDeviceRequest
	if returnFunc, ok := ret.Get(0).(func(context.Context, string) client.ApiDeviceAuthManagementDecommissionDeviceRequest); ok {
		r0 = returnFunc(ctx, id)
	} else {
		r0 = ret.Get(0).(client.ApiDeviceAuthManagementDecommissionDeviceRequest)
	}
	return r0
}

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

// DeviceAuthManagementDecommissionDevice is a helper method to define mock.On call
//   - ctx context.Context
//   - id string
func (_e *MockDeviceAuthenticationManagementAPIAPI_Expecter) DeviceAuthManagementDecommissionDevice(ctx interface{}, id interface{}) *MockDeviceAuthenticationManagementAPIAPI_DeviceAuthManagementDecommissionDevice_Call {
	return &MockDeviceAuthenticationManagementAPIAPI_DeviceAuthManagementDecommissionDevice_Call{Call: _e.mock.On("DeviceAuthManagementDecommissionDevice", ctx, id)}
}

func (_c *MockDeviceAuthenticationManagementAPIAPI_DeviceAuthManagementDecommissionDevice_Call) Run(run func(ctx context.Context, id string)) *MockDeviceAuthenticationManagementAPIAPI_DeviceAuthManagementDecommissionDevice_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 *MockDeviceAuthenticationManagementAPIAPI_DeviceAuthManagementDecommissionDevice_Call) Return(apiDeviceAuthManagementDecommissionDeviceRequest client.ApiDeviceAuthManagementDecommissionDeviceRequest) *MockDeviceAuthenticationManagementAPIAPI_DeviceAuthManagementDecommissionDevice_Call {
	_c.Call.Return(apiDeviceAuthManagementDecommissionDeviceRequest)
	return _c
}

func (_c *MockDeviceAuthenticationManagementAPIAPI_DeviceAuthManagementDecommissionDevice_Call) RunAndReturn(run func(ctx context.Context, id string) client.ApiDeviceAuthManagementDecommissionDeviceRequest) *MockDeviceAuthenticationManagementAPIAPI_DeviceAuthManagementDecommissionDevice_Call {
	_c.Call.Return(run)
	return _c
}

// DeviceAuthManagementDecommissionDeviceExecute provides a mock function for the type MockDeviceAuthenticationManagementAPIAPI
func (_mock *MockDeviceAuthenticationManagementAPIAPI) DeviceAuthManagementDecommissionDeviceExecute(r client.ApiDeviceAuthManagementDecommissionDeviceRequest) (*http.Response, error) {
	ret := _mock.Called(r)

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

	var r0 *http.Response
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(client.ApiDeviceAuthManagementDecommissionDeviceRequest) (*http.Response, error)); ok {
		return returnFunc(r)
	}
	if returnFunc, ok := ret.Get(0).(func(client.ApiDeviceAuthManagementDecommissionDeviceRequest) *http.Response); ok {
		r0 = returnFunc(r)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*http.Response)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(client.ApiDeviceAuthManagementDecommissionDeviceRequest) error); ok {
		r1 = returnFunc(r)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// DeviceAuthManagementDecommissionDeviceExecute is a helper method to define mock.On call
//   - r client.ApiDeviceAuthManagementDecommissionDeviceRequest
func (_e *MockDeviceAuthenticationManagementAPIAPI_Expecter) DeviceAuthManagementDecommissionDeviceExecute(r interface{}) *MockDeviceAuthenticationManagementAPIAPI_DeviceAuthManagementDecommissionDeviceExecute_Call {
	return &MockDeviceAuthenticationManagementAPIAPI_DeviceAuthManagementDecommissionDeviceExecute_Call{Call: _e.mock.On("DeviceAuthManagementDecommissionDeviceExecute", r)}
}

func (_c *MockDeviceAuthenticationManagementAPIAPI_DeviceAuthManagementDecommissionDeviceExecute_Call) Run(run func(r client.ApiDeviceAuthManagementDecommissionDeviceRequest)) *MockDeviceAuthenticationManagementAPIAPI_DeviceAuthManagementDecommissionDeviceExecute_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 client.ApiDeviceAuthManagementDecommissionDeviceRequest
		if args[0] != nil {
			arg0 = args[0].(client.ApiDeviceAuthManagementDecommissionDeviceRequest)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *MockDeviceAuthenticationManagementAPIAPI_DeviceAuthManagementDecommissionDeviceExecute_Call) Return(response *http.Response, err error) *MockDeviceAuthenticationManagementAPIAPI_DeviceAuthManagementDecommissionDeviceExecute_Call {
	_c.Call.Return(response, err)
	return _c
}

func (_c *MockDeviceAuthenticationManagementAPIAPI_DeviceAuthManagementDecommissionDeviceExecute_Call) RunAndReturn(run func(r client.ApiDeviceAuthManagementDecommissionDeviceRequest) (*http.Response, error)) *MockDeviceAuthenticationManagementAPIAPI_DeviceAuthManagementDecommissionDeviceExecute_Call {
	_c.Call.Return(run)
	return _c
}

// DeviceAuthManagementGetAuthenticationStatus provides a mock function for the type MockDeviceAuthenticationManagementAPIAPI
func (_mock *MockDeviceAuthenticationManagementAPIAPI) DeviceAuthManagementGetAuthenticationStatus(ctx context.Context, id string, aid string) client.ApiDeviceAuthManagementGetAuthenticationStatusRequest {
	ret := _mock.Called(ctx, id, aid)

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

	var r0 client.ApiDeviceAuthManagementGetAuthenticationStatusRequest
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string) client.ApiDeviceAuthManagementGetAuthenticationStatusRequest); ok {
		r0 = returnFunc(ctx, id, aid)
	} else {
		r0 = ret.Get(0).(client.ApiDeviceAuthManagementGetAuthenticationStatusRequest)
	}
	return r0
}

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

// DeviceAuthManagementGetAuthenticationStatus is a helper method to define mock.On call
//   - ctx context.Context
//   - id string
//   - aid string
func (_e *MockDeviceAuthenticationManagementAPIAPI_Expecter) DeviceAuthManagementGetAuthenticationStatus(ctx interface{}, id interface{}, aid interface{}) *MockDeviceAuthenticationManagementAPIAPI_DeviceAuthManagementGetAuthenticationStatus_Call {
	return &MockDeviceAuthenticationManagementAPIAPI_DeviceAuthManagementGetAuthenticationStatus_Call{Call: _e.mock.On("DeviceAuthManagementGetAuthenticationStatus", ctx, id, aid)}
}

func (_c *MockDeviceAuthenticationManagementAPIAPI_DeviceAuthManagementGetAuthenticationStatus_Call) Run(run func(ctx context.Context, id string, aid string)) *MockDeviceAuthenticationManagementAPIAPI_DeviceAuthManagementGetAuthenticationStatus_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)
		}
		run(
			arg0,
			arg1,
			arg2,
		)
	})
	return _c
}

func (_c *MockDeviceAuthenticationManagementAPIAPI_DeviceAuthManagementGetAuthenticationStatus_Call) Return(apiDeviceAuthManagementGetAuthenticationStatusRequest client.ApiDeviceAuthManagementGetAuthenticationStatusRequest) *MockDeviceAuthenticationManagementAPIAPI_DeviceAuthManagementGetAuthenticationStatus_Call {
	_c.Call.Return(apiDeviceAuthManagementGetAuthenticationStatusRequest)
	return _c
}

func (_c *MockDeviceAuthenticationManagementAPIAPI_DeviceAuthManagementGetAuthenticationStatus_Call) RunAndReturn(run func(ctx context.Context, id string, aid string) client.ApiDeviceAuthManagementGetAuthenticationStatusRequest) *MockDeviceAuthenticationManagementAPIAPI_DeviceAuthManagementGetAuthenticationStatus_Call {
	_c.Call.Return(run)
	return _c
}

// DeviceAuthManagementGetAuthenticationStatusExecute provides a mock function for the type MockDeviceAuthenticationManagementAPIAPI
func (_mock *MockDeviceAuthenticationManagementAPIAPI) DeviceAuthManagementGetAuthenticationStatusExecute(r client.ApiDeviceAuthManagementGetAuthenticationStatusRequest) (*client.Status, *http.Response, error) {
	ret := _mock.Called(r)

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

	var r0 *client.Status
	var r1 *http.Response
	var r2 error
	if returnFunc, ok := ret.Get(0).(func(client.ApiDeviceAuthManagementGetAuthenticationStatusRequest) (*client.Status, *http.Response, error)); ok {
		return returnFunc(r)
	}
	if returnFunc, ok := ret.Get(0).(func(client.ApiDeviceAuthManagementGetAuthenticationStatusRequest) *client.Status); ok {
		r0 = returnFunc(r)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*client.Status)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(client.ApiDeviceAuthManagementGetAuthenticationStatusRequest) *http.Response); ok {
		r1 = returnFunc(r)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*http.Response)
		}
	}
	if returnFunc, ok := ret.Get(2).(func(client.ApiDeviceAuthManagementGetAuthenticationStatusRequest) error); ok {
		r2 = returnFunc(r)
	} else {
		r2 = ret.Error(2)
	}
	return r0, r1, r2
}

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

// DeviceAuthManagementGetAuthenticationStatusExecute is a helper method to define mock.On call
//   - r client.ApiDeviceAuthManagementGetAuthenticationStatusRequest
func (_e *MockDeviceAuthenticationManagementAPIAPI_Expecter) DeviceAuthManagementGetAuthenticationStatusExecute(r interface{}) *MockDeviceAuthenticationManagementAPIAPI_DeviceAuthManagementGetAuthenticationStatusExecute_Call {
	return &MockDeviceAuthenticationManagementAPIAPI_DeviceAuthManagementGetAuthenticationStatusExecute_Call{Call: _e.mock.On("DeviceAuthManagementGetAuthenticationStatusExecute", r)}
}

func (_c *MockDeviceAuthenticationManagementAPIAPI_DeviceAuthManagementGetAuthenticationStatusExecute_Call) Run(run func(r client.ApiDeviceAuthManagementGetAuthenticationStatusRequest)) *MockDeviceAuthenticationManagementAPIAPI_DeviceAuthManagementGetAuthenticationStatusExecute_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 client.ApiDeviceAuthManagementGetAuthenticationStatusRequest
		if args[0] != nil {
			arg0 = args[0].(client.ApiDeviceAuthManagementGetAuthenticationStatusRequest)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *MockDeviceAuthenticationManagementAPIAPI_DeviceAuthManagementGetAuthenticationStatusExecute_Call) Return(status *client.Status, response *http.Response, err error) *MockDeviceAuthenticationManagementAPIAPI_DeviceAuthManagementGetAuthenticationStatusExecute_Call {
	_c.Call.Return(status, response, err)
	return _c
}

func (_c *MockDeviceAuthenticationManagementAPIAPI_DeviceAuthManagementGetAuthenticationStatusExecute_Call) RunAndReturn(run func(r client.ApiDeviceAuthManagementGetAuthenticationStatusRequest) (*client.Status, *http.Response, error)) *MockDeviceAuthenticationManagementAPIAPI_DeviceAuthManagementGetAuthenticationStatusExecute_Call {
	_c.Call.Return(run)
	return _c
}

// DeviceAuthManagementGetDevice provides a mock function for the type MockDeviceAuthenticationManagementAPIAPI
func (_mock *MockDeviceAuthenticationManagementAPIAPI) DeviceAuthManagementGetDevice(ctx context.Context, id string) client.ApiDeviceAuthManagementGetDeviceRequest {
	ret := _mock.Called(ctx, id)

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

	var r0 client.ApiDeviceAuthManagementGetDeviceRequest
	if returnFunc, ok := ret.Get(0).(func(context.Context, string) client.ApiDeviceAuthManagementGetDeviceRequest); ok {
		r0 = returnFunc(ctx, id)
	} else {
		r0 = ret.Get(0).(client.ApiDeviceAuthManagementGetDeviceRequest)
	}
	return r0
}

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

// DeviceAuthManagementGetDevice is a helper method to define mock.On call
//   - ctx context.Context
//   - id string
func (_e *MockDeviceAuthenticationManagementAPIAPI_Expecter) DeviceAuthManagementGetDevice(ctx interface{}, id interface{}) *MockDeviceAuthenticationManagementAPIAPI_DeviceAuthManagementGetDevice_Call {
	return &MockDeviceAuthenticationManagementAPIAPI_DeviceAuthManagementGetDevice_Call{Call: _e.mock.On("DeviceAuthManagementGetDevice", ctx, id)}
}

func (_c *MockDeviceAuthenticationManagementAPIAPI_DeviceAuthManagementGetDevice_Call) Run(run func(ctx context.Context, id string)) *MockDeviceAuthenticationManagementAPIAPI_DeviceAuthManagementGetDevice_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 *MockDeviceAuthenticationManagementAPIAPI_DeviceAuthManagementGetDevice_Call) Return(apiDeviceAuthManagementGetDeviceRequest client.ApiDeviceAuthManagementGetDeviceRequest) *MockDeviceAuthenticationManagementAPIAPI_DeviceAuthManagementGetDevice_Call {
	_c.Call.Return(apiDeviceAuthManagementGetDeviceRequest)
	return _c
}

func (_c *MockDeviceAuthenticationManagementAPIAPI_DeviceAuthManagementGetDevice_Call) RunAndReturn(run func(ctx context.Context, id string) client.ApiDeviceAuthManagementGetDeviceRequest) *MockDeviceAuthenticationManagementAPIAPI_DeviceAuthManagementGetDevice_Call {
	_c.Call.Return(run)
	return _c
}

// DeviceAuthManagementGetDeviceExecute provides a mock function for the type MockDeviceAuthenticationManagementAPIAPI
func (_mock *MockDeviceAuthenticationManagementAPIAPI) DeviceAuthManagementGetDeviceExecute(r client.ApiDeviceAuthManagementGetDeviceRequest) (*client.Device, *http.Response, error) {
	ret := _mock.Called(r)

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

	var r0 *client.Device
	var r1 *http.Response
	var r2 error
	if returnFunc, ok := ret.Get(0).(func(client.ApiDeviceAuthManagementGetDeviceRequest) (*client.Device, *http.Response, error)); ok {
		return returnFunc(r)
	}
	if returnFunc, ok := ret.Get(0).(func(client.ApiDeviceAuthManagementGetDeviceRequest) *client.Device); ok {
		r0 = returnFunc(r)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*client.Device)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(client.ApiDeviceAuthManagementGetDeviceRequest) *http.Response); ok {
		r1 = returnFunc(r)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*http.Response)
		}
	}
	if returnFunc, ok := ret.Get(2).(func(client.ApiDeviceAuthManagementGetDeviceRequest) error); ok {
		r2 = returnFunc(r)
	} else {
		r2 = ret.Error(2)
	}
	return r0, r1, r2
}

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

// DeviceAuthManagementGetDeviceExecute is a helper method to define mock.On call
//   - r client.ApiDeviceAuthManagementGetDeviceRequest
func (_e *MockDeviceAuthenticationManagementAPIAPI_Expecter) DeviceAuthManagementGetDeviceExecute(r interface{}) *MockDeviceAuthenticationManagementAPIAPI_DeviceAuthManagementGetDeviceExecute_Call {
	return &MockDeviceAuthenticationManagementAPIAPI_DeviceAuthManagementGetDeviceExecute_Call{Call: _e.mock.On("DeviceAuthManagementGetDeviceExecute", r)}
}

func (_c *MockDeviceAuthenticationManagementAPIAPI_DeviceAuthManagementGetDeviceExecute_Call) Run(run func(r client.ApiDeviceAuthManagementGetDeviceRequest)) *MockDeviceAuthenticationManagementAPIAPI_DeviceAuthManagementGetDeviceExecute_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 client.ApiDeviceAuthManagementGetDeviceRequest
		if args[0] != nil {
			arg0 = args[0].(client.ApiDeviceAuthManagementGetDeviceRequest)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *MockDeviceAuthenticationManagementAPIAPI_DeviceAuthManagementGetDeviceExecute_Call) Return(device *client.Device, response *http.Response, err error) *MockDeviceAuthenticationManagementAPIAPI_DeviceAuthManagementGetDeviceExecute_Call {
	_c.Call.Return(device, response, err)
	return _c
}

func (_c *MockDeviceAuthenticationManagementAPIAPI_DeviceAuthManagementGetDeviceExecute_Call) RunAndReturn(run func(r client.ApiDeviceAuthManagementGetDeviceRequest) (*client.Device, *http.Response, error)) *MockDeviceAuthenticationManagementAPIAPI_DeviceAuthManagementGetDeviceExecute_Call {
	_c.Call.Return(run)
	return _c
}

// DeviceAuthManagementGetDeviceLimit provides a mock function for the type MockDeviceAuthenticationManagementAPIAPI
func (_mock *MockDeviceAuthenticationManagementAPIAPI) DeviceAuthManagementGetDeviceLimit(ctx context.Context) client.ApiDeviceAuthManagementGetDeviceLimitRequest {
	ret := _mock.Called(ctx)

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

	var r0 client.ApiDeviceAuthManagementGetDeviceLimitRequest
	if returnFunc, ok := ret.Get(0).(func(context.Context) client.ApiDeviceAuthManagementGetDeviceLimitRequest); ok {
		r0 = returnFunc(ctx)
	} else {
		r0 = ret.Get(0).(client.ApiDeviceAuthManagementGetDeviceLimitRequest)
	}
	return r0
}

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

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

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

func (_c *MockDeviceAuthenticationManagementAPIAPI_DeviceAuthManagementGetDeviceLimit_Call) Return(apiDeviceAuthManagementGetDeviceLimitRequest client.ApiDeviceAuthManagementGetDeviceLimitRequest) *MockDeviceAuthenticationManagementAPIAPI_DeviceAuthManagementGetDeviceLimit_Call {
	_c.Call.Return(apiDeviceAuthManagementGetDeviceLimitRequest)
	return _c
}

func (_c *MockDeviceAuthenticationManagementAPIAPI_DeviceAuthManagementGetDeviceLimit_Call) RunAndReturn(run func(ctx context.Context) client.ApiDeviceAuthManagementGetDeviceLimitRequest) *MockDeviceAuthenticationManagementAPIAPI_DeviceAuthManagementGetDeviceLimit_Call {
	_c.Call.Return(run)
	return _c
}

// DeviceAuthManagementGetDeviceLimitExecute provides a mock function for the type MockDeviceAuthenticationManagementAPIAPI
func (_mock *MockDeviceAuthenticationManagementAPIAPI) DeviceAuthManagementGetDeviceLimitExecute(r client.ApiDeviceAuthManagementGetDeviceLimitRequest) (*client.Limit, *http.Response, error) {
	ret := _mock.Called(r)

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

	var r0 *client.Limit
	var r1 *http.Response
	var r2 error
	if returnFunc, ok := ret.Get(0).(func(client.ApiDeviceAuthManagementGetDeviceLimitRequest) (*client.Limit, *http.Response, error)); ok {
		return returnFunc(r)
	}
	if returnFunc, ok := ret.Get(0).(func(client.ApiDeviceAuthManagementGetDeviceLimitRequest) *client.Limit); ok {
		r0 = returnFunc(r)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*client.Limit)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(client.ApiDeviceAuthManagementGetDeviceLimitRequest) *http.Response); ok {
		r1 = returnFunc(r)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*http.Response)
		}
	}
	if returnFunc, ok := ret.Get(2).(func(client.ApiDeviceAuthManagementGetDeviceLimitRequest) error); ok {
		r2 = returnFunc(r)
	} else {
		r2 = ret.Error(2)
	}
	return r0, r1, r2
}

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

// DeviceAuthManagementGetDeviceLimitExecute is a helper method to define mock.On call
//   - r client.ApiDeviceAuthManagementGetDeviceLimitRequest
func (_e *MockDeviceAuthenticationManagementAPIAPI_Expecter) DeviceAuthManagementGetDeviceLimitExecute(r interface{}) *MockDeviceAuthenticationManagementAPIAPI_DeviceAuthManagementGetDeviceLimitExecute_Call {
	return &MockDeviceAuthenticationManagementAPIAPI_DeviceAuthManagementGetDeviceLimitExecute_Call{Call: _e.mock.On("DeviceAuthManagementGetDeviceLimitExecute", r)}
}

func (_c *MockDeviceAuthenticationManagementAPIAPI_DeviceAuthManagementGetDeviceLimitExecute_Call) Run(run func(r client.ApiDeviceAuthManagementGetDeviceLimitRequest)) *MockDeviceAuthenticationManagementAPIAPI_DeviceAuthManagementGetDeviceLimitExecute_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 client.ApiDeviceAuthManagementGetDeviceLimitRequest
		if args[0] != nil {
			arg0 = args[0].(client.ApiDeviceAuthManagementGetDeviceLimitRequest)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *MockDeviceAuthenticationManagementAPIAPI_DeviceAuthManagementGetDeviceLimitExecute_Call) Return(limit *client.Limit, response *http.Response, err error) *MockDeviceAuthenticationManagementAPIAPI_DeviceAuthManagementGetDeviceLimitExecute_Call {
	_c.Call.Return(limit, response, err)
	return _c
}

func (_c *MockDeviceAuthenticationManagementAPIAPI_DeviceAuthManagementGetDeviceLimitExecute_Call) RunAndReturn(run func(r client.ApiDeviceAuthManagementGetDeviceLimitRequest) (*client.Limit, *http.Response, error)) *MockDeviceAuthenticationManagementAPIAPI_DeviceAuthManagementGetDeviceLimitExecute_Call {
	_c.Call.Return(run)
	return _c
}

// DeviceAuthManagementListDevices provides a mock function for the type MockDeviceAuthenticationManagementAPIAPI
func (_mock *MockDeviceAuthenticationManagementAPIAPI) DeviceAuthManagementListDevices(ctx context.Context) client.ApiDeviceAuthManagementListDevicesRequest {
	ret := _mock.Called(ctx)

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

	var r0 client.ApiDeviceAuthManagementListDevicesRequest
	if returnFunc, ok := ret.Get(0).(func(context.Context) client.ApiDeviceAuthManagementListDevicesRequest); ok {
		r0 = returnFunc(ctx)
	} else {
		r0 = ret.Get(0).(client.ApiDeviceAuthManagementListDevicesRequest)
	}
	return r0
}

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

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

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

func (_c *MockDeviceAuthenticationManagementAPIAPI_DeviceAuthManagementListDevices_Call) Return(apiDeviceAuthManagementListDevicesRequest client.ApiDeviceAuthManagementListDevicesRequest) *MockDeviceAuthenticationManagementAPIAPI_DeviceAuthManagementListDevices_Call {
	_c.Call.Return(apiDeviceAuthManagementListDevicesRequest)
	return _c
}

func (_c *MockDeviceAuthenticationManagementAPIAPI_DeviceAuthManagementListDevices_Call) RunAndReturn(run func(ctx context.Context) client.ApiDeviceAuthManagementListDevicesRequest) *MockDeviceAuthenticationManagementAPIAPI_DeviceAuthManagementListDevices_Call {
	_c.Call.Return(run)
	return _c
}

// DeviceAuthManagementListDevicesExecute provides a mock function for the type MockDeviceAuthenticationManagementAPIAPI
func (_mock *MockDeviceAuthenticationManagementAPIAPI) DeviceAuthManagementListDevicesExecute(r client.ApiDeviceAuthManagementListDevicesRequest) ([]client.Device, *http.Response, error) {
	ret := _mock.Called(r)

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

	var r0 []client.Device
	var r1 *http.Response
	var r2 error
	if returnFunc, ok := ret.Get(0).(func(client.ApiDeviceAuthManagementListDevicesRequest) ([]client.Device, *http.Response, error)); ok {
		return returnFunc(r)
	}
	if returnFunc, ok := ret.Get(0).(func(client.ApiDeviceAuthManagementListDevicesRequest) []client.Device); ok {
		r0 = returnFunc(r)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]client.Device)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(client.ApiDeviceAuthManagementListDevicesRequest) *http.Response); ok {
		r1 = returnFunc(r)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*http.Response)
		}
	}
	if returnFunc, ok := ret.Get(2).(func(client.ApiDeviceAuthManagementListDevicesRequest) error); ok {
		r2 = returnFunc(r)
	} else {
		r2 = ret.Error(2)
	}
	return r0, r1, r2
}

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

// DeviceAuthManagementListDevicesExecute is a helper method to define mock.On call
//   - r client.ApiDeviceAuthManagementListDevicesRequest
func (_e *MockDeviceAuthenticationManagementAPIAPI_Expecter) DeviceAuthManagementListDevicesExecute(r interface{}) *MockDeviceAuthenticationManagementAPIAPI_DeviceAuthManagementListDevicesExecute_Call {
	return &MockDeviceAuthenticationManagementAPIAPI_DeviceAuthManagementListDevicesExecute_Call{Call: _e.mock.On("DeviceAuthManagementListDevicesExecute", r)}
}

func (_c *MockDeviceAuthenticationManagementAPIAPI_DeviceAuthManagementListDevicesExecute_Call) Run(run func(r client.ApiDeviceAuthManagementListDevicesRequest)) *MockDeviceAuthenticationManagementAPIAPI_DeviceAuthManagementListDevicesExecute_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 client.ApiDeviceAuthManagementListDevicesRequest
		if args[0] != nil {
			arg0 = args[0].(client.ApiDeviceAuthManagementListDevicesRequest)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *MockDeviceAuthenticationManagementAPIAPI_DeviceAuthManagementListDevicesExecute_Call) Return(devices []client.Device, response *http.Response, err error) *MockDeviceAuthenticationManagementAPIAPI_DeviceAuthManagementListDevicesExecute_Call {
	_c.Call.Return(devices, response, err)
	return _c
}

func (_c *MockDeviceAuthenticationManagementAPIAPI_DeviceAuthManagementListDevicesExecute_Call) RunAndReturn(run func(r client.ApiDeviceAuthManagementListDevicesRequest) ([]client.Device, *http.Response, error)) *MockDeviceAuthenticationManagementAPIAPI_DeviceAuthManagementListDevicesExecute_Call {
	_c.Call.Return(run)
	return _c
}

// DeviceAuthManagementPreauthorize provides a mock function for the type MockDeviceAuthenticationManagementAPIAPI
func (_mock *MockDeviceAuthenticationManagementAPIAPI) DeviceAuthManagementPreauthorize(ctx context.Context) client.ApiDeviceAuthManagementPreauthorizeRequest {
	ret := _mock.Called(ctx)

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

	var r0 client.ApiDeviceAuthManagementPreauthorizeRequest
	if returnFunc, ok := ret.Get(0).(func(context.Context) client.ApiDeviceAuthManagementPreauthorizeRequest); ok {
		r0 = returnFunc(ctx)
	} else {
		r0 = ret.Get(0).(client.ApiDeviceAuthManagementPreauthorizeRequest)
	}
	return r0
}

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

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

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

func (_c *MockDeviceAuthenticationManagementAPIAPI_DeviceAuthManagementPreauthorize_Call) Return(apiDeviceAuthManagementPreauthorizeRequest client.ApiDeviceAuthManagementPreauthorizeRequest) *MockDeviceAuthenticationManagementAPIAPI_DeviceAuthManagementPreauthorize_Call {
	_c.Call.Return(apiDeviceAuthManagementPreauthorizeRequest)
	return _c
}

func (_c *MockDeviceAuthenticationManagementAPIAPI_DeviceAuthManagementPreauthorize_Call) RunAndReturn(run func(ctx context.Context) client.ApiDeviceAuthManagementPreauthorizeRequest) *MockDeviceAuthenticationManagementAPIAPI_DeviceAuthManagementPreauthorize_Call {
	_c.Call.Return(run)
	return _c
}

// DeviceAuthManagementPreauthorizeExecute provides a mock function for the type MockDeviceAuthenticationManagementAPIAPI
func (_mock *MockDeviceAuthenticationManagementAPIAPI) DeviceAuthManagementPreauthorizeExecute(r client.ApiDeviceAuthManagementPreauthorizeRequest) (*http.Response, error) {
	ret := _mock.Called(r)

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

	var r0 *http.Response
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(client.ApiDeviceAuthManagementPreauthorizeRequest) (*http.Response, error)); ok {
		return returnFunc(r)
	}
	if returnFunc, ok := ret.Get(0).(func(client.ApiDeviceAuthManagementPreauthorizeRequest) *http.Response); ok {
		r0 = returnFunc(r)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*http.Response)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(client.ApiDeviceAuthManagementPreauthorizeRequest) error); ok {
		r1 = returnFunc(r)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// DeviceAuthManagementPreauthorizeExecute is a helper method to define mock.On call
//   - r client.ApiDeviceAuthManagementPreauthorizeRequest
func (_e *MockDeviceAuthenticationManagementAPIAPI_Expecter) DeviceAuthManagementPreauthorizeExecute(r interface{}) *MockDeviceAuthenticationManagementAPIAPI_DeviceAuthManagementPreauthorizeExecute_Call {
	return &MockDeviceAuthenticationManagementAPIAPI_DeviceAuthManagementPreauthorizeExecute_Call{Call: _e.mock.On("DeviceAuthManagementPreauthorizeExecute", r)}
}

func (_c *MockDeviceAuthenticationManagementAPIAPI_DeviceAuthManagementPreauthorizeExecute_Call) Run(run func(r client.ApiDeviceAuthManagementPreauthorizeRequest)) *MockDeviceAuthenticationManagementAPIAPI_DeviceAuthManagementPreauthorizeExecute_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 client.ApiDeviceAuthManagementPreauthorizeRequest
		if args[0] != nil {
			arg0 = args[0].(client.ApiDeviceAuthManagementPreauthorizeRequest)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *MockDeviceAuthenticationManagementAPIAPI_DeviceAuthManagementPreauthorizeExecute_Call) Return(response *http.Response, err error) *MockDeviceAuthenticationManagementAPIAPI_DeviceAuthManagementPreauthorizeExecute_Call {
	_c.Call.Return(response, err)
	return _c
}

func (_c *MockDeviceAuthenticationManagementAPIAPI_DeviceAuthManagementPreauthorizeExecute_Call) RunAndReturn(run func(r client.ApiDeviceAuthManagementPreauthorizeRequest) (*http.Response, error)) *MockDeviceAuthenticationManagementAPIAPI_DeviceAuthManagementPreauthorizeExecute_Call {
	_c.Call.Return(run)
	return _c
}

// DeviceAuthManagementRemoveAuthentication provides a mock function for the type MockDeviceAuthenticationManagementAPIAPI
func (_mock *MockDeviceAuthenticationManagementAPIAPI) DeviceAuthManagementRemoveAuthentication(ctx context.Context, id string, aid string) client.ApiDeviceAuthManagementRemoveAuthenticationRequest {
	ret := _mock.Called(ctx, id, aid)

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

	var r0 client.ApiDeviceAuthManagementRemoveAuthenticationRequest
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string) client.ApiDeviceAuthManagementRemoveAuthenticationRequest); ok {
		r0 = returnFunc(ctx, id, aid)
	} else {
		r0 = ret.Get(0).(client.ApiDeviceAuthManagementRemoveAuthenticationRequest)
	}
	return r0
}

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

// DeviceAuthManagementRemoveAuthentication is a helper method to define mock.On call
//   - ctx context.Context
//   - id string
//   - aid string
func (_e *MockDeviceAuthenticationManagementAPIAPI_Expecter) DeviceAuthManagementRemoveAuthentication(ctx interface{}, id interface{}, aid interface{}) *MockDeviceAuthenticationManagementAPIAPI_DeviceAuthManagementRemoveAuthentication_Call {
	return &MockDeviceAuthenticationManagementAPIAPI_DeviceAuthManagementRemoveAuthentication_Call{Call: _e.mock.On("DeviceAuthManagementRemoveAuthentication", ctx, id, aid)}
}

func (_c *MockDeviceAuthenticationManagementAPIAPI_DeviceAuthManagementRemoveAuthentication_Call) Run(run func(ctx context.Context, id string, aid string)) *MockDeviceAuthenticationManagementAPIAPI_DeviceAuthManagementRemoveAuthentication_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)
		}
		run(
			arg0,
			arg1,
			arg2,
		)
	})
	return _c
}

func (_c *MockDeviceAuthenticationManagementAPIAPI_DeviceAuthManagementRemoveAuthentication_Call) Return(apiDeviceAuthManagementRemoveAuthenticationRequest client.ApiDeviceAuthManagementRemoveAuthenticationRequest) *MockDeviceAuthenticationManagementAPIAPI_DeviceAuthManagementRemoveAuthentication_Call {
	_c.Call.Return(apiDeviceAuthManagementRemoveAuthenticationRequest)
	return _c
}

func (_c *MockDeviceAuthenticationManagementAPIAPI_DeviceAuthManagementRemoveAuthentication_Call) RunAndReturn(run func(ctx context.Context, id string, aid string) client.ApiDeviceAuthManagementRemoveAuthenticationRequest) *MockDeviceAuthenticationManagementAPIAPI_DeviceAuthManagementRemoveAuthentication_Call {
	_c.Call.Return(run)
	return _c
}

// DeviceAuthManagementRemoveAuthenticationExecute provides a mock function for the type MockDeviceAuthenticationManagementAPIAPI
func (_mock *MockDeviceAuthenticationManagementAPIAPI) DeviceAuthManagementRemoveAuthenticationExecute(r client.ApiDeviceAuthManagementRemoveAuthenticationRequest) (*http.Response, error) {
	ret := _mock.Called(r)

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

	var r0 *http.Response
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(client.ApiDeviceAuthManagementRemoveAuthenticationRequest) (*http.Response, error)); ok {
		return returnFunc(r)
	}
	if returnFunc, ok := ret.Get(0).(func(client.ApiDeviceAuthManagementRemoveAuthenticationRequest) *http.Response); ok {
		r0 = returnFunc(r)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*http.Response)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(client.ApiDeviceAuthManagementRemoveAuthenticationRequest) error); ok {
		r1 = returnFunc(r)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// DeviceAuthManagementRemoveAuthenticationExecute is a helper method to define mock.On call
//   - r client.ApiDeviceAuthManagementRemoveAuthenticationRequest
func (_e *MockDeviceAuthenticationManagementAPIAPI_Expecter) DeviceAuthManagementRemoveAuthenticationExecute(r interface{}) *MockDeviceAuthenticationManagementAPIAPI_DeviceAuthManagementRemoveAuthenticationExecute_Call {
	return &MockDeviceAuthenticationManagementAPIAPI_DeviceAuthManagementRemoveAuthenticationExecute_Call{Call: _e.mock.On("DeviceAuthManagementRemoveAuthenticationExecute", r)}
}

func (_c *MockDeviceAuthenticationManagementAPIAPI_DeviceAuthManagementRemoveAuthenticationExecute_Call) Run(run func(r client.ApiDeviceAuthManagementRemoveAuthenticationRequest)) *MockDeviceAuthenticationManagementAPIAPI_DeviceAuthManagementRemoveAuthenticationExecute_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 client.ApiDeviceAuthManagementRemoveAuthenticationRequest
		if args[0] != nil {
			arg0 = args[0].(client.ApiDeviceAuthManagementRemoveAuthenticationRequest)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *MockDeviceAuthenticationManagementAPIAPI_DeviceAuthManagementRemoveAuthenticationExecute_Call) Return(response *http.Response, err error) *MockDeviceAuthenticationManagementAPIAPI_DeviceAuthManagementRemoveAuthenticationExecute_Call {
	_c.Call.Return(response, err)
	return _c
}

func (_c *MockDeviceAuthenticationManagementAPIAPI_DeviceAuthManagementRemoveAuthenticationExecute_Call) RunAndReturn(run func(r client.ApiDeviceAuthManagementRemoveAuthenticationRequest) (*http.Response, error)) *MockDeviceAuthenticationManagementAPIAPI_DeviceAuthManagementRemoveAuthenticationExecute_Call {
	_c.Call.Return(run)
	return _c
}

// DeviceAuthManagementRevokeAPIToken provides a mock function for the type MockDeviceAuthenticationManagementAPIAPI
func (_mock *MockDeviceAuthenticationManagementAPIAPI) DeviceAuthManagementRevokeAPIToken(ctx context.Context, id string) client.ApiDeviceAuthManagementRevokeAPITokenRequest {
	ret := _mock.Called(ctx, id)

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

	var r0 client.ApiDeviceAuthManagementRevokeAPITokenRequest
	if returnFunc, ok := ret.Get(0).(func(context.Context, string) client.ApiDeviceAuthManagementRevokeAPITokenRequest); ok {
		r0 = returnFunc(ctx, id)
	} else {
		r0 = ret.Get(0).(client.ApiDeviceAuthManagementRevokeAPITokenRequest)
	}
	return r0
}

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

// DeviceAuthManagementRevokeAPIToken is a helper method to define mock.On call
//   - ctx context.Context
//   - id string
func (_e *MockDeviceAuthenticationManagementAPIAPI_Expecter) DeviceAuthManagementRevokeAPIToken(ctx interface{}, id interface{}) *MockDeviceAuthenticationManagementAPIAPI_DeviceAuthManagementRevokeAPIToken_Call {
	return &MockDeviceAuthenticationManagementAPIAPI_DeviceAuthManagementRevokeAPIToken_Call{Call: _e.mock.On("DeviceAuthManagementRevokeAPIToken", ctx, id)}
}

func (_c *MockDeviceAuthenticationManagementAPIAPI_DeviceAuthManagementRevokeAPIToken_Call) Run(run func(ctx context.Context, id string)) *MockDeviceAuthenticationManagementAPIAPI_DeviceAuthManagementRevokeAPIToken_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 *MockDeviceAuthenticationManagementAPIAPI_DeviceAuthManagementRevokeAPIToken_Call) Return(apiDeviceAuthManagementRevokeAPITokenRequest client.ApiDeviceAuthManagementRevokeAPITokenRequest) *MockDeviceAuthenticationManagementAPIAPI_DeviceAuthManagementRevokeAPIToken_Call {
	_c.Call.Return(apiDeviceAuthManagementRevokeAPITokenRequest)
	return _c
}

func (_c *MockDeviceAuthenticationManagementAPIAPI_DeviceAuthManagementRevokeAPIToken_Call) RunAndReturn(run func(ctx context.Context, id string) client.ApiDeviceAuthManagementRevokeAPITokenRequest) *MockDeviceAuthenticationManagementAPIAPI_DeviceAuthManagementRevokeAPIToken_Call {
	_c.Call.Return(run)
	return _c
}

// DeviceAuthManagementRevokeAPITokenExecute provides a mock function for the type MockDeviceAuthenticationManagementAPIAPI
func (_mock *MockDeviceAuthenticationManagementAPIAPI) DeviceAuthManagementRevokeAPITokenExecute(r client.ApiDeviceAuthManagementRevokeAPITokenRequest) (*http.Response, error) {
	ret := _mock.Called(r)

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

	var r0 *http.Response
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(client.ApiDeviceAuthManagementRevokeAPITokenRequest) (*http.Response, error)); ok {
		return returnFunc(r)
	}
	if returnFunc, ok := ret.Get(0).(func(client.ApiDeviceAuthManagementRevokeAPITokenRequest) *http.Response); ok {
		r0 = returnFunc(r)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*http.Response)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(client.ApiDeviceAuthManagementRevokeAPITokenRequest) error); ok {
		r1 = returnFunc(r)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// DeviceAuthManagementRevokeAPITokenExecute is a helper method to define mock.On call
//   - r client.ApiDeviceAuthManagementRevokeAPITokenRequest
func (_e *MockDeviceAuthenticationManagementAPIAPI_Expecter) DeviceAuthManagementRevokeAPITokenExecute(r interface{}) *MockDeviceAuthenticationManagementAPIAPI_DeviceAuthManagementRevokeAPITokenExecute_Call {
	return &MockDeviceAuthenticationManagementAPIAPI_DeviceAuthManagementRevokeAPITokenExecute_Call{Call: _e.mock.On("DeviceAuthManagementRevokeAPITokenExecute", r)}
}

func (_c *MockDeviceAuthenticationManagementAPIAPI_DeviceAuthManagementRevokeAPITokenExecute_Call) Run(run func(r client.ApiDeviceAuthManagementRevokeAPITokenRequest)) *MockDeviceAuthenticationManagementAPIAPI_DeviceAuthManagementRevokeAPITokenExecute_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 client.ApiDeviceAuthManagementRevokeAPITokenRequest
		if args[0] != nil {
			arg0 = args[0].(client.ApiDeviceAuthManagementRevokeAPITokenRequest)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *MockDeviceAuthenticationManagementAPIAPI_DeviceAuthManagementRevokeAPITokenExecute_Call) Return(response *http.Response, err error) *MockDeviceAuthenticationManagementAPIAPI_DeviceAuthManagementRevokeAPITokenExecute_Call {
	_c.Call.Return(response, err)
	return _c
}

func (_c *MockDeviceAuthenticationManagementAPIAPI_DeviceAuthManagementRevokeAPITokenExecute_Call) RunAndReturn(run func(r client.ApiDeviceAuthManagementRevokeAPITokenRequest) (*http.Response, error)) *MockDeviceAuthenticationManagementAPIAPI_DeviceAuthManagementRevokeAPITokenExecute_Call {
	_c.Call.Return(run)
	return _c
}

// DeviceAuthManagementSearchDevices provides a mock function for the type MockDeviceAuthenticationManagementAPIAPI
func (_mock *MockDeviceAuthenticationManagementAPIAPI) DeviceAuthManagementSearchDevices(ctx context.Context) client.ApiDeviceAuthManagementSearchDevicesRequest {
	ret := _mock.Called(ctx)

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

	var r0 client.ApiDeviceAuthManagementSearchDevicesRequest
	if returnFunc, ok := ret.Get(0).(func(context.Context) client.ApiDeviceAuthManagementSearchDevicesRequest); ok {
		r0 = returnFunc(ctx)
	} else {
		r0 = ret.Get(0).(client.ApiDeviceAuthManagementSearchDevicesRequest)
	}
	return r0
}

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

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

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

func (_c *MockDeviceAuthenticationManagementAPIAPI_DeviceAuthManagementSearchDevices_Call) Return(apiDeviceAuthManagementSearchDevicesRequest client.ApiDeviceAuthManagementSearchDevicesRequest) *MockDeviceAuthenticationManagementAPIAPI_DeviceAuthManagementSearchDevices_Call {
	_c.Call.Return(apiDeviceAuthManagementSearchDevicesRequest)
	return _c
}

func (_c *MockDeviceAuthenticationManagementAPIAPI_DeviceAuthManagementSearchDevices_Call) RunAndReturn(run func(ctx context.Context) client.ApiDeviceAuthManagementSearchDevicesRequest) *MockDeviceAuthenticationManagementAPIAPI_DeviceAuthManagementSearchDevices_Call {
	_c.Call.Return(run)
	return _c
}

// DeviceAuthManagementSearchDevicesExecute provides a mock function for the type MockDeviceAuthenticationManagementAPIAPI
func (_mock *MockDeviceAuthenticationManagementAPIAPI) DeviceAuthManagementSearchDevicesExecute(r client.ApiDeviceAuthManagementSearchDevicesRequest) ([]client.Device, *http.Response, error) {
	ret := _mock.Called(r)

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

	var r0 []client.Device
	var r1 *http.Response
	var r2 error
	if returnFunc, ok := ret.Get(0).(func(client.ApiDeviceAuthManagementSearchDevicesRequest) ([]client.Device, *http.Response, error)); ok {
		return returnFunc(r)
	}
	if returnFunc, ok := ret.Get(0).(func(client.ApiDeviceAuthManagementSearchDevicesRequest) []client.Device); ok {
		r0 = returnFunc(r)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]client.Device)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(client.ApiDeviceAuthManagementSearchDevicesRequest) *http.Response); ok {
		r1 = returnFunc(r)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*http.Response)
		}
	}
	if returnFunc, ok := ret.Get(2).(func(client.ApiDeviceAuthManagementSearchDevicesRequest) error); ok {
		r2 = returnFunc(r)
	} else {
		r2 = ret.Error(2)
	}
	return r0, r1, r2
}

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

// DeviceAuthManagementSearchDevicesExecute is a helper method to define mock.On call
//   - r client.ApiDeviceAuthManagementSearchDevicesRequest
func (_e *MockDeviceAuthenticationManagementAPIAPI_Expecter) DeviceAuthManagementSearchDevicesExecute(r interface{}) *MockDeviceAuthenticationManagementAPIAPI_DeviceAuthManagementSearchDevicesExecute_Call {
	return &MockDeviceAuthenticationManagementAPIAPI_DeviceAuthManagementSearchDevicesExecute_Call{Call: _e.mock.On("DeviceAuthManagementSearchDevicesExecute", r)}
}

func (_c *MockDeviceAuthenticationManagementAPIAPI_DeviceAuthManagementSearchDevicesExecute_Call) Run(run func(r client.ApiDeviceAuthManagementSearchDevicesRequest)) *MockDeviceAuthenticationManagementAPIAPI_DeviceAuthManagementSearchDevicesExecute_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 client.ApiDeviceAuthManagementSearchDevicesRequest
		if args[0] != nil {
			arg0 = args[0].(client.ApiDeviceAuthManagementSearchDevicesRequest)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *MockDeviceAuthenticationManagementAPIAPI_DeviceAuthManagementSearchDevicesExecute_Call) Return(devices []client.Device, response *http.Response, err error) *MockDeviceAuthenticationManagementAPIAPI_DeviceAuthManagementSearchDevicesExecute_Call {
	_c.Call.Return(devices, response, err)
	return _c
}

func (_c *MockDeviceAuthenticationManagementAPIAPI_DeviceAuthManagementSearchDevicesExecute_Call) RunAndReturn(run func(r client.ApiDeviceAuthManagementSearchDevicesRequest) ([]client.Device, *http.Response, error)) *MockDeviceAuthenticationManagementAPIAPI_DeviceAuthManagementSearchDevicesExecute_Call {
	_c.Call.Return(run)
	return _c
}

// DeviceAuthManagementSetAuthenticationStatus provides a mock function for the type MockDeviceAuthenticationManagementAPIAPI
func (_mock *MockDeviceAuthenticationManagementAPIAPI) DeviceAuthManagementSetAuthenticationStatus(ctx context.Context, id string, aid string) client.ApiDeviceAuthManagementSetAuthenticationStatusRequest {
	ret := _mock.Called(ctx, id, aid)

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

	var r0 client.ApiDeviceAuthManagementSetAuthenticationStatusRequest
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string) client.ApiDeviceAuthManagementSetAuthenticationStatusRequest); ok {
		r0 = returnFunc(ctx, id, aid)
	} else {
		r0 = ret.Get(0).(client.ApiDeviceAuthManagementSetAuthenticationStatusRequest)
	}
	return r0
}

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

// DeviceAuthManagementSetAuthenticationStatus is a helper method to define mock.On call
//   - ctx context.Context
//   - id string
//   - aid string
func (_e *MockDeviceAuthenticationManagementAPIAPI_Expecter) DeviceAuthManagementSetAuthenticationStatus(ctx interface{}, id interface{}, aid interface{}) *MockDeviceAuthenticationManagementAPIAPI_DeviceAuthManagementSetAuthenticationStatus_Call {
	return &MockDeviceAuthenticationManagementAPIAPI_DeviceAuthManagementSetAuthenticationStatus_Call{Call: _e.mock.On("DeviceAuthManagementSetAuthenticationStatus", ctx, id, aid)}
}

func (_c *MockDeviceAuthenticationManagementAPIAPI_DeviceAuthManagementSetAuthenticationStatus_Call) Run(run func(ctx context.Context, id string, aid string)) *MockDeviceAuthenticationManagementAPIAPI_DeviceAuthManagementSetAuthenticationStatus_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)
		}
		run(
			arg0,
			arg1,
			arg2,
		)
	})
	return _c
}

func (_c *MockDeviceAuthenticationManagementAPIAPI_DeviceAuthManagementSetAuthenticationStatus_Call) Return(apiDeviceAuthManagementSetAuthenticationStatusRequest client.ApiDeviceAuthManagementSetAuthenticationStatusRequest) *MockDeviceAuthenticationManagementAPIAPI_DeviceAuthManagementSetAuthenticationStatus_Call {
	_c.Call.Return(apiDeviceAuthManagementSetAuthenticationStatusRequest)
	return _c
}

func (_c *MockDeviceAuthenticationManagementAPIAPI_DeviceAuthManagementSetAuthenticationStatus_Call) RunAndReturn(run func(ctx context.Context, id string, aid string) client.ApiDeviceAuthManagementSetAuthenticationStatusRequest) *MockDeviceAuthenticationManagementAPIAPI_DeviceAuthManagementSetAuthenticationStatus_Call {
	_c.Call.Return(run)
	return _c
}

// DeviceAuthManagementSetAuthenticationStatusExecute provides a mock function for the type MockDeviceAuthenticationManagementAPIAPI
func (_mock *MockDeviceAuthenticationManagementAPIAPI) DeviceAuthManagementSetAuthenticationStatusExecute(r client.ApiDeviceAuthManagementSetAuthenticationStatusRequest) (*http.Response, error) {
	ret := _mock.Called(r)

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

	var r0 *http.Response
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(client.ApiDeviceAuthManagementSetAuthenticationStatusRequest) (*http.Response, error)); ok {
		return returnFunc(r)
	}
	if returnFunc, ok := ret.Get(0).(func(client.ApiDeviceAuthManagementSetAuthenticationStatusRequest) *http.Response); ok {
		r0 = returnFunc(r)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*http.Response)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(client.ApiDeviceAuthManagementSetAuthenticationStatusRequest) error); ok {
		r1 = returnFunc(r)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// DeviceAuthManagementSetAuthenticationStatusExecute is a helper method to define mock.On call
//   - r client.ApiDeviceAuthManagementSetAuthenticationStatusRequest
func (_e *MockDeviceAuthenticationManagementAPIAPI_Expecter) DeviceAuthManagementSetAuthenticationStatusExecute(r interface{}) *MockDeviceAuthenticationManagementAPIAPI_DeviceAuthManagementSetAuthenticationStatusExecute_Call {
	return &MockDeviceAuthenticationManagementAPIAPI_DeviceAuthManagementSetAuthenticationStatusExecute_Call{Call: _e.mock.On("DeviceAuthManagementSetAuthenticationStatusExecute", r)}
}

func (_c *MockDeviceAuthenticationManagementAPIAPI_DeviceAuthManagementSetAuthenticationStatusExecute_Call) Run(run func(r client.ApiDeviceAuthManagementSetAuthenticationStatusRequest)) *MockDeviceAuthenticationManagementAPIAPI_DeviceAuthManagementSetAuthenticationStatusExecute_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 client.ApiDeviceAuthManagementSetAuthenticationStatusRequest
		if args[0] != nil {
			arg0 = args[0].(client.ApiDeviceAuthManagementSetAuthenticationStatusRequest)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *MockDeviceAuthenticationManagementAPIAPI_DeviceAuthManagementSetAuthenticationStatusExecute_Call) Return(response *http.Response, err error) *MockDeviceAuthenticationManagementAPIAPI_DeviceAuthManagementSetAuthenticationStatusExecute_Call {
	_c.Call.Return(response, err)
	return _c
}

func (_c *MockDeviceAuthenticationManagementAPIAPI_DeviceAuthManagementSetAuthenticationStatusExecute_Call) RunAndReturn(run func(r client.ApiDeviceAuthManagementSetAuthenticationStatusRequest) (*http.Response, error)) *MockDeviceAuthenticationManagementAPIAPI_DeviceAuthManagementSetAuthenticationStatusExecute_Call {
	_c.Call.Return(run)
	return _c
}

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

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

	return mock
}

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

type MockDeviceConfigureDeviceAPIAPI_Expecter struct {
	mock *mock.Mock
}

func (_m *MockDeviceConfigureDeviceAPIAPI) EXPECT() *MockDeviceConfigureDeviceAPIAPI_Expecter {
	return &MockDeviceConfigureDeviceAPIAPI_Expecter{mock: &_m.Mock}
}

// DeviceConfigGetDeviceConfiguration provides a mock function for the type MockDeviceConfigureDeviceAPIAPI
func (_mock *MockDeviceConfigureDeviceAPIAPI) DeviceConfigGetDeviceConfiguration(ctx context.Context) client.ApiDeviceConfigGetDeviceConfigurationRequest {
	ret := _mock.Called(ctx)

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

	var r0 client.ApiDeviceConfigGetDeviceConfigurationRequest
	if returnFunc, ok := ret.Get(0).(func(context.Context) client.ApiDeviceConfigGetDeviceConfigurationRequest); ok {
		r0 = returnFunc(ctx)
	} else {
		r0 = ret.Get(0).(client.ApiDeviceConfigGetDeviceConfigurationRequest)
	}
	return r0
}

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

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

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

func (_c *MockDeviceConfigureDeviceAPIAPI_DeviceConfigGetDeviceConfiguration_Call) Return(apiDeviceConfigGetDeviceConfigurationRequest client.ApiDeviceConfigGetDeviceConfigurationRequest) *MockDeviceConfigureDeviceAPIAPI_DeviceConfigGetDeviceConfiguration_Call {
	_c.Call.Return(apiDeviceConfigGetDeviceConfigurationRequest)
	return _c
}

func (_c *MockDeviceConfigureDeviceAPIAPI_DeviceConfigGetDeviceConfiguration_Call) RunAndReturn(run func(ctx context.Context) client.ApiDeviceConfigGetDeviceConfigurationRequest) *MockDeviceConfigureDeviceAPIAPI_DeviceConfigGetDeviceConfiguration_Call {
	_c.Call.Return(run)
	return _c
}

// DeviceConfigGetDeviceConfigurationExecute provides a mock function for the type MockDeviceConfigureDeviceAPIAPI
func (_mock *MockDeviceConfigureDeviceAPIAPI) DeviceConfigGetDeviceConfigurationExecute(r client.ApiDeviceConfigGetDeviceConfigurationRequest) (map[string]string, *http.Response, error) {
	ret := _mock.Called(r)

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

	var r0 map[string]string
	var r1 *http.Response
	var r2 error
	if returnFunc, ok := ret.Get(0).(func(client.ApiDeviceConfigGetDeviceConfigurationRequest) (map[string]string, *http.Response, error)); ok {
		return returnFunc(r)
	}
	if returnFunc, ok := ret.Get(0).(func(client.ApiDeviceConfigGetDeviceConfigurationRequest) map[string]string); ok {
		r0 = returnFunc(r)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(map[string]string)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(client.ApiDeviceConfigGetDeviceConfigurationRequest) *http.Response); ok {
		r1 = returnFunc(r)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*http.Response)
		}
	}
	if returnFunc, ok := ret.Get(2).(func(client.ApiDeviceConfigGetDeviceConfigurationRequest) error); ok {
		r2 = returnFunc(r)
	} else {
		r2 = ret.Error(2)
	}
	return r0, r1, r2
}

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

// DeviceConfigGetDeviceConfigurationExecute is a helper method to define mock.On call
//   - r client.ApiDeviceConfigGetDeviceConfigurationRequest
func (_e *MockDeviceConfigureDeviceAPIAPI_Expecter) DeviceConfigGetDeviceConfigurationExecute(r interface{}) *MockDeviceConfigureDeviceAPIAPI_DeviceConfigGetDeviceConfigurationExecute_Call {
	return &MockDeviceConfigureDeviceAPIAPI_DeviceConfigGetDeviceConfigurationExecute_Call{Call: _e.mock.On("DeviceConfigGetDeviceConfigurationExecute", r)}
}

func (_c *MockDeviceConfigureDeviceAPIAPI_DeviceConfigGetDeviceConfigurationExecute_Call) Run(run func(r client.ApiDeviceConfigGetDeviceConfigurationRequest)) *MockDeviceConfigureDeviceAPIAPI_DeviceConfigGetDeviceConfigurationExecute_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 client.ApiDeviceConfigGetDeviceConfigurationRequest
		if args[0] != nil {
			arg0 = args[0].(client.ApiDeviceConfigGetDeviceConfigurationRequest)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *MockDeviceConfigureDeviceAPIAPI_DeviceConfigGetDeviceConfigurationExecute_Call) Return(stringToString map[string]string, response *http.Response, err error) *MockDeviceConfigureDeviceAPIAPI_DeviceConfigGetDeviceConfigurationExecute_Call {
	_c.Call.Return(stringToString, response, err)
	return _c
}

func (_c *MockDeviceConfigureDeviceAPIAPI_DeviceConfigGetDeviceConfigurationExecute_Call) RunAndReturn(run func(r client.ApiDeviceConfigGetDeviceConfigurationRequest) (map[string]string, *http.Response, error)) *MockDeviceConfigureDeviceAPIAPI_DeviceConfigGetDeviceConfigurationExecute_Call {
	_c.Call.Return(run)
	return _c
}

// DeviceConfigReportDeviceConfiguration provides a mock function for the type MockDeviceConfigureDeviceAPIAPI
func (_mock *MockDeviceConfigureDeviceAPIAPI) DeviceConfigReportDeviceConfiguration(ctx context.Context) client.ApiDeviceConfigReportDeviceConfigurationRequest {
	ret := _mock.Called(ctx)

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

	var r0 client.ApiDeviceConfigReportDeviceConfigurationRequest
	if returnFunc, ok := ret.Get(0).(func(context.Context) client.ApiDeviceConfigReportDeviceConfigurationRequest); ok {
		r0 = returnFunc(ctx)
	} else {
		r0 = ret.Get(0).(client.ApiDeviceConfigReportDeviceConfigurationRequest)
	}
	return r0
}

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

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

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

func (_c *MockDeviceConfigureDeviceAPIAPI_DeviceConfigReportDeviceConfiguration_Call) Return(apiDeviceConfigReportDeviceConfigurationRequest client.ApiDeviceConfigReportDeviceConfigurationRequest) *MockDeviceConfigureDeviceAPIAPI_DeviceConfigReportDeviceConfiguration_Call {
	_c.Call.Return(apiDeviceConfigReportDeviceConfigurationRequest)
	return _c
}

func (_c *MockDeviceConfigureDeviceAPIAPI_DeviceConfigReportDeviceConfiguration_Call) RunAndReturn(run func(ctx context.Context) client.ApiDeviceConfigReportDeviceConfigurationRequest) *MockDeviceConfigureDeviceAPIAPI_DeviceConfigReportDeviceConfiguration_Call {
	_c.Call.Return(run)
	return _c
}

// DeviceConfigReportDeviceConfigurationExecute provides a mock function for the type MockDeviceConfigureDeviceAPIAPI
func (_mock *MockDeviceConfigureDeviceAPIAPI) DeviceConfigReportDeviceConfigurationExecute(r client.ApiDeviceConfigReportDeviceConfigurationRequest) (*http.Response, error) {
	ret := _mock.Called(r)

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

	var r0 *http.Response
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(client.ApiDeviceConfigReportDeviceConfigurationRequest) (*http.Response, error)); ok {
		return returnFunc(r)
	}
	if returnFunc, ok := ret.Get(0).(func(client.ApiDeviceConfigReportDeviceConfigurationRequest) *http.Response); ok {
		r0 = returnFunc(r)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*http.Response)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(client.ApiDeviceConfigReportDeviceConfigurationRequest) error); ok {
		r1 = returnFunc(r)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// DeviceConfigReportDeviceConfigurationExecute is a helper method to define mock.On call
//   - r client.ApiDeviceConfigReportDeviceConfigurationRequest
func (_e *MockDeviceConfigureDeviceAPIAPI_Expecter) DeviceConfigReportDeviceConfigurationExecute(r interface{}) *MockDeviceConfigureDeviceAPIAPI_DeviceConfigReportDeviceConfigurationExecute_Call {
	return &MockDeviceConfigureDeviceAPIAPI_DeviceConfigReportDeviceConfigurationExecute_Call{Call: _e.mock.On("DeviceConfigReportDeviceConfigurationExecute", r)}
}

func (_c *MockDeviceConfigureDeviceAPIAPI_DeviceConfigReportDeviceConfigurationExecute_Call) Run(run func(r client.ApiDeviceConfigReportDeviceConfigurationRequest)) *MockDeviceConfigureDeviceAPIAPI_DeviceConfigReportDeviceConfigurationExecute_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 client.ApiDeviceConfigReportDeviceConfigurationRequest
		if args[0] != nil {
			arg0 = args[0].(client.ApiDeviceConfigReportDeviceConfigurationRequest)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *MockDeviceConfigureDeviceAPIAPI_DeviceConfigReportDeviceConfigurationExecute_Call) Return(response *http.Response, err error) *MockDeviceConfigureDeviceAPIAPI_DeviceConfigReportDeviceConfigurationExecute_Call {
	_c.Call.Return(response, err)
	return _c
}

func (_c *MockDeviceConfigureDeviceAPIAPI_DeviceConfigReportDeviceConfigurationExecute_Call) RunAndReturn(run func(r client.ApiDeviceConfigReportDeviceConfigurationRequest) (*http.Response, error)) *MockDeviceConfigureDeviceAPIAPI_DeviceConfigReportDeviceConfigurationExecute_Call {
	_c.Call.Return(run)
	return _c
}

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

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

	return mock
}

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

type MockDeviceConfigureInternalAPIAPI_Expecter struct {
	mock *mock.Mock
}

func (_m *MockDeviceConfigureInternalAPIAPI) EXPECT() *MockDeviceConfigureInternalAPIAPI_Expecter {
	return &MockDeviceConfigureInternalAPIAPI_Expecter{mock: &_m.Mock}
}

// DeviceConfigInternalCheckHealth provides a mock function for the type MockDeviceConfigureInternalAPIAPI
func (_mock *MockDeviceConfigureInternalAPIAPI) DeviceConfigInternalCheckHealth(ctx context.Context) client.ApiDeviceConfigInternalCheckHealthRequest {
	ret := _mock.Called(ctx)

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

	var r0 client.ApiDeviceConfigInternalCheckHealthRequest
	if returnFunc, ok := ret.Get(0).(func(context.Context) client.ApiDeviceConfigInternalCheckHealthRequest); ok {
		r0 = returnFunc(ctx)
	} else {
		r0 = ret.Get(0).(client.ApiDeviceConfigInternalCheckHealthRequest)
	}
	return r0
}

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

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

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

func (_c *MockDeviceConfigureInternalAPIAPI_DeviceConfigInternalCheckHealth_Call) Return(apiDeviceConfigInternalCheckHealthRequest client.ApiDeviceConfigInternalCheckHealthRequest) *MockDeviceConfigureInternalAPIAPI_DeviceConfigInternalCheckHealth_Call {
	_c.Call.Return(apiDeviceConfigInternalCheckHealthRequest)
	return _c
}

func (_c *MockDeviceConfigureInternalAPIAPI_DeviceConfigInternalCheckHealth_Call) RunAndReturn(run func(ctx context.Context) client.ApiDeviceConfigInternalCheckHealthRequest) *MockDeviceConfigureInternalAPIAPI_DeviceConfigInternalCheckHealth_Call {
	_c.Call.Return(run)
	return _c
}

// DeviceConfigInternalCheckHealthExecute provides a mock function for the type MockDeviceConfigureInternalAPIAPI
func (_mock *MockDeviceConfigureInternalAPIAPI) DeviceConfigInternalCheckHealthExecute(r client.ApiDeviceConfigInternalCheckHealthRequest) (*http.Response, error) {
	ret := _mock.Called(r)

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

	var r0 *http.Response
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(client.ApiDeviceConfigInternalCheckHealthRequest) (*http.Response, error)); ok {
		return returnFunc(r)
	}
	if returnFunc, ok := ret.Get(0).(func(client.ApiDeviceConfigInternalCheckHealthRequest) *http.Response); ok {
		r0 = returnFunc(r)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*http.Response)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(client.ApiDeviceConfigInternalCheckHealthRequest) error); ok {
		r1 = returnFunc(r)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// DeviceConfigInternalCheckHealthExecute is a helper method to define mock.On call
//   - r client.ApiDeviceConfigInternalCheckHealthRequest
func (_e *MockDeviceConfigureInternalAPIAPI_Expecter) DeviceConfigInternalCheckHealthExecute(r interface{}) *MockDeviceConfigureInternalAPIAPI_DeviceConfigInternalCheckHealthExecute_Call {
	return &MockDeviceConfigureInternalAPIAPI_DeviceConfigInternalCheckHealthExecute_Call{Call: _e.mock.On("DeviceConfigInternalCheckHealthExecute", r)}
}

func (_c *MockDeviceConfigureInternalAPIAPI_DeviceConfigInternalCheckHealthExecute_Call) Run(run func(r client.ApiDeviceConfigInternalCheckHealthRequest)) *MockDeviceConfigureInternalAPIAPI_DeviceConfigInternalCheckHealthExecute_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 client.ApiDeviceConfigInternalCheckHealthRequest
		if args[0] != nil {
			arg0 = args[0].(client.ApiDeviceConfigInternalCheckHealthRequest)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *MockDeviceConfigureInternalAPIAPI_DeviceConfigInternalCheckHealthExecute_Call) Return(response *http.Response, err error) *MockDeviceConfigureInternalAPIAPI_DeviceConfigInternalCheckHealthExecute_Call {
	_c.Call.Return(response, err)
	return _c
}

func (_c *MockDeviceConfigureInternalAPIAPI_DeviceConfigInternalCheckHealthExecute_Call) RunAndReturn(run func(r client.ApiDeviceConfigInternalCheckHealthRequest) (*http.Response, error)) *MockDeviceConfigureInternalAPIAPI_DeviceConfigInternalCheckHealthExecute_Call {
	_c.Call.Return(run)
	return _c
}

// DeviceConfigInternalCheckLiveliness provides a mock function for the type MockDeviceConfigureInternalAPIAPI
func (_mock *MockDeviceConfigureInternalAPIAPI) DeviceConfigInternalCheckLiveliness(ctx context.Context) client.ApiDeviceConfigInternalCheckLivelinessRequest {
	ret := _mock.Called(ctx)

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

	var r0 client.ApiDeviceConfigInternalCheckLivelinessRequest
	if returnFunc, ok := ret.Get(0).(func(context.Context) client.ApiDeviceConfigInternalCheckLivelinessRequest); ok {
		r0 = returnFunc(ctx)
	} else {
		r0 = ret.Get(0).(client.ApiDeviceConfigInternalCheckLivelinessRequest)
	}
	return r0
}

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

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

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

func (_c *MockDeviceConfigureInternalAPIAPI_DeviceConfigInternalCheckLiveliness_Call) Return(apiDeviceConfigInternalCheckLivelinessRequest client.ApiDeviceConfigInternalCheckLivelinessRequest) *MockDeviceConfigureInternalAPIAPI_DeviceConfigInternalCheckLiveliness_Call {
	_c.Call.Return(apiDeviceConfigInternalCheckLivelinessRequest)
	return _c
}

func (_c *MockDeviceConfigureInternalAPIAPI_DeviceConfigInternalCheckLiveliness_Call) RunAndReturn(run func(ctx context.Context) client.ApiDeviceConfigInternalCheckLivelinessRequest) *MockDeviceConfigureInternalAPIAPI_DeviceConfigInternalCheckLiveliness_Call {
	_c.Call.Return(run)
	return _c
}

// DeviceConfigInternalCheckLivelinessExecute provides a mock function for the type MockDeviceConfigureInternalAPIAPI
func (_mock *MockDeviceConfigureInternalAPIAPI) DeviceConfigInternalCheckLivelinessExecute(r client.ApiDeviceConfigInternalCheckLivelinessRequest) (*http.Response, error) {
	ret := _mock.Called(r)

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

	var r0 *http.Response
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(client.ApiDeviceConfigInternalCheckLivelinessRequest) (*http.Response, error)); ok {
		return returnFunc(r)
	}
	if returnFunc, ok := ret.Get(0).(func(client.ApiDeviceConfigInternalCheckLivelinessRequest) *http.Response); ok {
		r0 = returnFunc(r)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*http.Response)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(client.ApiDeviceConfigInternalCheckLivelinessRequest) error); ok {
		r1 = returnFunc(r)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// DeviceConfigInternalCheckLivelinessExecute is a helper method to define mock.On call
//   - r client.ApiDeviceConfigInternalCheckLivelinessRequest
func (_e *MockDeviceConfigureInternalAPIAPI_Expecter) DeviceConfigInternalCheckLivelinessExecute(r interface{}) *MockDeviceConfigureInternalAPIAPI_DeviceConfigInternalCheckLivelinessExecute_Call {
	return &MockDeviceConfigureInternalAPIAPI_DeviceConfigInternalCheckLivelinessExecute_Call{Call: _e.mock.On("DeviceConfigInternalCheckLivelinessExecute", r)}
}

func (_c *MockDeviceConfigureInternalAPIAPI_DeviceConfigInternalCheckLivelinessExecute_Call) Run(run func(r client.ApiDeviceConfigInternalCheckLivelinessRequest)) *MockDeviceConfigureInternalAPIAPI_DeviceConfigInternalCheckLivelinessExecute_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 client.ApiDeviceConfigInternalCheckLivelinessRequest
		if args[0] != nil {
			arg0 = args[0].(client.ApiDeviceConfigInternalCheckLivelinessRequest)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *MockDeviceConfigureInternalAPIAPI_DeviceConfigInternalCheckLivelinessExecute_Call) Return(response *http.Response, err error) *MockDeviceConfigureInternalAPIAPI_DeviceConfigInternalCheckLivelinessExecute_Call {
	_c.Call.Return(response, err)
	return _c
}

func (_c *MockDeviceConfigureInternalAPIAPI_DeviceConfigInternalCheckLivelinessExecute_Call) RunAndReturn(run func(r client.ApiDeviceConfigInternalCheckLivelinessRequest) (*http.Response, error)) *MockDeviceConfigureInternalAPIAPI_DeviceConfigInternalCheckLivelinessExecute_Call {
	_c.Call.Return(run)
	return _c
}

// DeviceConfigInternalDecommissionDevice provides a mock function for the type MockDeviceConfigureInternalAPIAPI
func (_mock *MockDeviceConfigureInternalAPIAPI) DeviceConfigInternalDecommissionDevice(ctx context.Context, tenantId string, deviceId string) client.ApiDeviceConfigInternalDecommissionDeviceRequest {
	ret := _mock.Called(ctx, tenantId, deviceId)

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

	var r0 client.ApiDeviceConfigInternalDecommissionDeviceRequest
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string) client.ApiDeviceConfigInternalDecommissionDeviceRequest); ok {
		r0 = returnFunc(ctx, tenantId, deviceId)
	} else {
		r0 = ret.Get(0).(client.ApiDeviceConfigInternalDecommissionDeviceRequest)
	}
	return r0
}

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

// DeviceConfigInternalDecommissionDevice is a helper method to define mock.On call
//   - ctx context.Context
//   - tenantId string
//   - deviceId string
func (_e *MockDeviceConfigureInternalAPIAPI_Expecter) DeviceConfigInternalDecommissionDevice(ctx interface{}, tenantId interface{}, deviceId interface{}) *MockDeviceConfigureInternalAPIAPI_DeviceConfigInternalDecommissionDevice_Call {
	return &MockDeviceConfigureInternalAPIAPI_DeviceConfigInternalDecommissionDevice_Call{Call: _e.mock.On("DeviceConfigInternalDecommissionDevice", ctx, tenantId, deviceId)}
}

func (_c *MockDeviceConfigureInternalAPIAPI_DeviceConfigInternalDecommissionDevice_Call) Run(run func(ctx context.Context, tenantId string, deviceId string)) *MockDeviceConfigureInternalAPIAPI_DeviceConfigInternalDecommissionDevice_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)
		}
		run(
			arg0,
			arg1,
			arg2,
		)
	})
	return _c
}

func (_c *MockDeviceConfigureInternalAPIAPI_DeviceConfigInternalDecommissionDevice_Call) Return(apiDeviceConfigInternalDecommissionDeviceRequest client.ApiDeviceConfigInternalDecommissionDeviceRequest) *MockDeviceConfigureInternalAPIAPI_DeviceConfigInternalDecommissionDevice_Call {
	_c.Call.Return(apiDeviceConfigInternalDecommissionDeviceRequest)
	return _c
}

func (_c *MockDeviceConfigureInternalAPIAPI_DeviceConfigInternalDecommissionDevice_Call) RunAndReturn(run func(ctx context.Context, tenantId string, deviceId string) client.ApiDeviceConfigInternalDecommissionDeviceRequest) *MockDeviceConfigureInternalAPIAPI_DeviceConfigInternalDecommissionDevice_Call {
	_c.Call.Return(run)
	return _c
}

// DeviceConfigInternalDecommissionDeviceExecute provides a mock function for the type MockDeviceConfigureInternalAPIAPI
func (_mock *MockDeviceConfigureInternalAPIAPI) DeviceConfigInternalDecommissionDeviceExecute(r client.ApiDeviceConfigInternalDecommissionDeviceRequest) (*http.Response, error) {
	ret := _mock.Called(r)

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

	var r0 *http.Response
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(client.ApiDeviceConfigInternalDecommissionDeviceRequest) (*http.Response, error)); ok {
		return returnFunc(r)
	}
	if returnFunc, ok := ret.Get(0).(func(client.ApiDeviceConfigInternalDecommissionDeviceRequest) *http.Response); ok {
		r0 = returnFunc(r)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*http.Response)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(client.ApiDeviceConfigInternalDecommissionDeviceRequest) error); ok {
		r1 = returnFunc(r)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// DeviceConfigInternalDecommissionDeviceExecute is a helper method to define mock.On call
//   - r client.ApiDeviceConfigInternalDecommissionDeviceRequest
func (_e *MockDeviceConfigureInternalAPIAPI_Expecter) DeviceConfigInternalDecommissionDeviceExecute(r interface{}) *MockDeviceConfigureInternalAPIAPI_DeviceConfigInternalDecommissionDeviceExecute_Call {
	return &MockDeviceConfigureInternalAPIAPI_DeviceConfigInternalDecommissionDeviceExecute_Call{Call: _e.mock.On("DeviceConfigInternalDecommissionDeviceExecute", r)}
}

func (_c *MockDeviceConfigureInternalAPIAPI_DeviceConfigInternalDecommissionDeviceExecute_Call) Run(run func(r client.ApiDeviceConfigInternalDecommissionDeviceRequest)) *MockDeviceConfigureInternalAPIAPI_DeviceConfigInternalDecommissionDeviceExecute_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 client.ApiDeviceConfigInternalDecommissionDeviceRequest
		if args[0] != nil {
			arg0 = args[0].(client.ApiDeviceConfigInternalDecommissionDeviceRequest)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *MockDeviceConfigureInternalAPIAPI_DeviceConfigInternalDecommissionDeviceExecute_Call) Return(response *http.Response, err error) *MockDeviceConfigureInternalAPIAPI_DeviceConfigInternalDecommissionDeviceExecute_Call {
	_c.Call.Return(response, err)
	return _c
}

func (_c *MockDeviceConfigureInternalAPIAPI_DeviceConfigInternalDecommissionDeviceExecute_Call) RunAndReturn(run func(r client.ApiDeviceConfigInternalDecommissionDeviceRequest) (*http.Response, error)) *MockDeviceConfigureInternalAPIAPI_DeviceConfigInternalDecommissionDeviceExecute_Call {
	_c.Call.Return(run)
	return _c
}

// DeviceConfigInternalDeleteTenant provides a mock function for the type MockDeviceConfigureInternalAPIAPI
func (_mock *MockDeviceConfigureInternalAPIAPI) DeviceConfigInternalDeleteTenant(ctx context.Context, tenantId string) client.ApiDeviceConfigInternalDeleteTenantRequest {
	ret := _mock.Called(ctx, tenantId)

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

	var r0 client.ApiDeviceConfigInternalDeleteTenantRequest
	if returnFunc, ok := ret.Get(0).(func(context.Context, string) client.ApiDeviceConfigInternalDeleteTenantRequest); ok {
		r0 = returnFunc(ctx, tenantId)
	} else {
		r0 = ret.Get(0).(client.ApiDeviceConfigInternalDeleteTenantRequest)
	}
	return r0
}

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

// DeviceConfigInternalDeleteTenant is a helper method to define mock.On call
//   - ctx context.Context
//   - tenantId string
func (_e *MockDeviceConfigureInternalAPIAPI_Expecter) DeviceConfigInternalDeleteTenant(ctx interface{}, tenantId interface{}) *MockDeviceConfigureInternalAPIAPI_DeviceConfigInternalDeleteTenant_Call {
	return &MockDeviceConfigureInternalAPIAPI_DeviceConfigInternalDeleteTenant_Call{Call: _e.mock.On("DeviceConfigInternalDeleteTenant", ctx, tenantId)}
}

func (_c *MockDeviceConfigureInternalAPIAPI_DeviceConfigInternalDeleteTenant_Call) Run(run func(ctx context.Context, tenantId string)) *MockDeviceConfigureInternalAPIAPI_DeviceConfigInternalDeleteTenant_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 *MockDeviceConfigureInternalAPIAPI_DeviceConfigInternalDeleteTenant_Call) Return(apiDeviceConfigInternalDeleteTenantRequest client.ApiDeviceConfigInternalDeleteTenantRequest) *MockDeviceConfigureInternalAPIAPI_DeviceConfigInternalDeleteTenant_Call {
	_c.Call.Return(apiDeviceConfigInternalDeleteTenantRequest)
	return _c
}

func (_c *MockDeviceConfigureInternalAPIAPI_DeviceConfigInternalDeleteTenant_Call) RunAndReturn(run func(ctx context.Context, tenantId string) client.ApiDeviceConfigInternalDeleteTenantRequest) *MockDeviceConfigureInternalAPIAPI_DeviceConfigInternalDeleteTenant_Call {
	_c.Call.Return(run)
	return _c
}

// DeviceConfigInternalDeleteTenantExecute provides a mock function for the type MockDeviceConfigureInternalAPIAPI
func (_mock *MockDeviceConfigureInternalAPIAPI) DeviceConfigInternalDeleteTenantExecute(r client.ApiDeviceConfigInternalDeleteTenantRequest) (*http.Response, error) {
	ret := _mock.Called(r)

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

	var r0 *http.Response
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(client.ApiDeviceConfigInternalDeleteTenantRequest) (*http.Response, error)); ok {
		return returnFunc(r)
	}
	if returnFunc, ok := ret.Get(0).(func(client.ApiDeviceConfigInternalDeleteTenantRequest) *http.Response); ok {
		r0 = returnFunc(r)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*http.Response)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(client.ApiDeviceConfigInternalDeleteTenantRequest) error); ok {
		r1 = returnFunc(r)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// DeviceConfigInternalDeleteTenantExecute is a helper method to define mock.On call
//   - r client.ApiDeviceConfigInternalDeleteTenantRequest
func (_e *MockDeviceConfigureInternalAPIAPI_Expecter) DeviceConfigInternalDeleteTenantExecute(r interface{}) *MockDeviceConfigureInternalAPIAPI_DeviceConfigInternalDeleteTenantExecute_Call {
	return &MockDeviceConfigureInternalAPIAPI_DeviceConfigInternalDeleteTenantExecute_Call{Call: _e.mock.On("DeviceConfigInternalDeleteTenantExecute", r)}
}

func (_c *MockDeviceConfigureInternalAPIAPI_DeviceConfigInternalDeleteTenantExecute_Call) Run(run func(r client.ApiDeviceConfigInternalDeleteTenantRequest)) *MockDeviceConfigureInternalAPIAPI_DeviceConfigInternalDeleteTenantExecute_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 client.ApiDeviceConfigInternalDeleteTenantRequest
		if args[0] != nil {
			arg0 = args[0].(client.ApiDeviceConfigInternalDeleteTenantRequest)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *MockDeviceConfigureInternalAPIAPI_DeviceConfigInternalDeleteTenantExecute_Call) Return(response *http.Response, err error) *MockDeviceConfigureInternalAPIAPI_DeviceConfigInternalDeleteTenantExecute_Call {
	_c.Call.Return(response, err)
	return _c
}

func (_c *MockDeviceConfigureInternalAPIAPI_DeviceConfigInternalDeleteTenantExecute_Call) RunAndReturn(run func(r client.ApiDeviceConfigInternalDeleteTenantRequest) (*http.Response, error)) *MockDeviceConfigureInternalAPIAPI_DeviceConfigInternalDeleteTenantExecute_Call {
	_c.Call.Return(run)
	return _c
}

// DeviceConfigInternalDeployDeviceConfiguration provides a mock function for the type MockDeviceConfigureInternalAPIAPI
func (_mock *MockDeviceConfigureInternalAPIAPI) DeviceConfigInternalDeployDeviceConfiguration(ctx context.Context, deviceId string, tenantId string) client.ApiDeviceConfigInternalDeployDeviceConfigurationRequest {
	ret := _mock.Called(ctx, deviceId, tenantId)

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

	var r0 client.ApiDeviceConfigInternalDeployDeviceConfigurationRequest
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string) client.ApiDeviceConfigInternalDeployDeviceConfigurationRequest); ok {
		r0 = returnFunc(ctx, deviceId, tenantId)
	} else {
		r0 = ret.Get(0).(client.ApiDeviceConfigInternalDeployDeviceConfigurationRequest)
	}
	return r0
}

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

// DeviceConfigInternalDeployDeviceConfiguration is a helper method to define mock.On call
//   - ctx context.Context
//   - deviceId string
//   - tenantId string
func (_e *MockDeviceConfigureInternalAPIAPI_Expecter) DeviceConfigInternalDeployDeviceConfiguration(ctx interface{}, deviceId interface{}, tenantId interface{}) *MockDeviceConfigureInternalAPIAPI_DeviceConfigInternalDeployDeviceConfiguration_Call {
	return &MockDeviceConfigureInternalAPIAPI_DeviceConfigInternalDeployDeviceConfiguration_Call{Call: _e.mock.On("DeviceConfigInternalDeployDeviceConfiguration", ctx, deviceId, tenantId)}
}

func (_c *MockDeviceConfigureInternalAPIAPI_DeviceConfigInternalDeployDeviceConfiguration_Call) Run(run func(ctx context.Context, deviceId string, tenantId string)) *MockDeviceConfigureInternalAPIAPI_DeviceConfigInternalDeployDeviceConfiguration_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)
		}
		run(
			arg0,
			arg1,
			arg2,
		)
	})
	return _c
}

func (_c *MockDeviceConfigureInternalAPIAPI_DeviceConfigInternalDeployDeviceConfiguration_Call) Return(apiDeviceConfigInternalDeployDeviceConfigurationRequest client.ApiDeviceConfigInternalDeployDeviceConfigurationRequest) *MockDeviceConfigureInternalAPIAPI_DeviceConfigInternalDeployDeviceConfiguration_Call {
	_c.Call.Return(apiDeviceConfigInternalDeployDeviceConfigurationRequest)
	return _c
}

func (_c *MockDeviceConfigureInternalAPIAPI_DeviceConfigInternalDeployDeviceConfiguration_Call) RunAndReturn(run func(ctx context.Context, deviceId string, tenantId string) client.ApiDeviceConfigInternalDeployDeviceConfigurationRequest) *MockDeviceConfigureInternalAPIAPI_DeviceConfigInternalDeployDeviceConfiguration_Call {
	_c.Call.Return(run)
	return _c
}

// DeviceConfigInternalDeployDeviceConfigurationExecute provides a mock function for the type MockDeviceConfigureInternalAPIAPI
func (_mock *MockDeviceConfigureInternalAPIAPI) DeviceConfigInternalDeployDeviceConfigurationExecute(r client.ApiDeviceConfigInternalDeployDeviceConfigurationRequest) (*client.NewConfigurationDeploymentResponse, *http.Response, error) {
	ret := _mock.Called(r)

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

	var r0 *client.NewConfigurationDeploymentResponse
	var r1 *http.Response
	var r2 error
	if returnFunc, ok := ret.Get(0).(func(client.ApiDeviceConfigInternalDeployDeviceConfigurationRequest) (*client.NewConfigurationDeploymentResponse, *http.Response, error)); ok {
		return returnFunc(r)
	}
	if returnFunc, ok := ret.Get(0).(func(client.ApiDeviceConfigInternalDeployDeviceConfigurationRequest) *client.NewConfigurationDeploymentResponse); ok {
		r0 = returnFunc(r)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*client.NewConfigurationDeploymentResponse)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(client.ApiDeviceConfigInternalDeployDeviceConfigurationRequest) *http.Response); ok {
		r1 = returnFunc(r)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*http.Response)
		}
	}
	if returnFunc, ok := ret.Get(2).(func(client.ApiDeviceConfigInternalDeployDeviceConfigurationRequest) error); ok {
		r2 = returnFunc(r)
	} else {
		r2 = ret.Error(2)
	}
	return r0, r1, r2
}

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

// DeviceConfigInternalDeployDeviceConfigurationExecute is a helper method to define mock.On call
//   - r client.ApiDeviceConfigInternalDeployDeviceConfigurationRequest
func (_e *MockDeviceConfigureInternalAPIAPI_Expecter) DeviceConfigInternalDeployDeviceConfigurationExecute(r interface{}) *MockDeviceConfigureInternalAPIAPI_DeviceConfigInternalDeployDeviceConfigurationExecute_Call {
	return &MockDeviceConfigureInternalAPIAPI_DeviceConfigInternalDeployDeviceConfigurationExecute_Call{Call: _e.mock.On("DeviceConfigInternalDeployDeviceConfigurationExecute", r)}
}

func (_c *MockDeviceConfigureInternalAPIAPI_DeviceConfigInternalDeployDeviceConfigurationExecute_Call) Run(run func(r client.ApiDeviceConfigInternalDeployDeviceConfigurationRequest)) *MockDeviceConfigureInternalAPIAPI_DeviceConfigInternalDeployDeviceConfigurationExecute_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 client.ApiDeviceConfigInternalDeployDeviceConfigurationRequest
		if args[0] != nil {
			arg0 = args[0].(client.ApiDeviceConfigInternalDeployDeviceConfigurationRequest)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *MockDeviceConfigureInternalAPIAPI_DeviceConfigInternalDeployDeviceConfigurationExecute_Call) Return(newConfigurationDeploymentResponse *client.NewConfigurationDeploymentResponse, response *http.Response, err error) *MockDeviceConfigureInternalAPIAPI_DeviceConfigInternalDeployDeviceConfigurationExecute_Call {
	_c.Call.Return(newConfigurationDeploymentResponse, response, err)
	return _c
}

func (_c *MockDeviceConfigureInternalAPIAPI_DeviceConfigInternalDeployDeviceConfigurationExecute_Call) RunAndReturn(run func(r client.ApiDeviceConfigInternalDeployDeviceConfigurationRequest) (*client.NewConfigurationDeploymentResponse, *http.Response, error)) *MockDeviceConfigureInternalAPIAPI_DeviceConfigInternalDeployDeviceConfigurationExecute_Call {
	_c.Call.Return(run)
	return _c
}

// DeviceConfigInternalProvisionDevice provides a mock function for the type MockDeviceConfigureInternalAPIAPI
func (_mock *MockDeviceConfigureInternalAPIAPI) DeviceConfigInternalProvisionDevice(ctx context.Context, tenantId string) client.ApiDeviceConfigInternalProvisionDeviceRequest {
	ret := _mock.Called(ctx, tenantId)

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

	var r0 client.ApiDeviceConfigInternalProvisionDeviceRequest
	if returnFunc, ok := ret.Get(0).(func(context.Context, string) client.ApiDeviceConfigInternalProvisionDeviceRequest); ok {
		r0 = returnFunc(ctx, tenantId)
	} else {
		r0 = ret.Get(0).(client.ApiDeviceConfigInternalProvisionDeviceRequest)
	}
	return r0
}

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

// DeviceConfigInternalProvisionDevice is a helper method to define mock.On call
//   - ctx context.Context
//   - tenantId string
func (_e *MockDeviceConfigureInternalAPIAPI_Expecter) DeviceConfigInternalProvisionDevice(ctx interface{}, tenantId interface{}) *MockDeviceConfigureInternalAPIAPI_DeviceConfigInternalProvisionDevice_Call {
	return &MockDeviceConfigureInternalAPIAPI_DeviceConfigInternalProvisionDevice_Call{Call: _e.mock.On("DeviceConfigInternalProvisionDevice", ctx, tenantId)}
}

func (_c *MockDeviceConfigureInternalAPIAPI_DeviceConfigInternalProvisionDevice_Call) Run(run func(ctx context.Context, tenantId string)) *MockDeviceConfigureInternalAPIAPI_DeviceConfigInternalProvisionDevice_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 *MockDeviceConfigureInternalAPIAPI_DeviceConfigInternalProvisionDevice_Call) Return(apiDeviceConfigInternalProvisionDeviceRequest client.ApiDeviceConfigInternalProvisionDeviceRequest) *MockDeviceConfigureInternalAPIAPI_DeviceConfigInternalProvisionDevice_Call {
	_c.Call.Return(apiDeviceConfigInternalProvisionDeviceRequest)
	return _c
}

func (_c *MockDeviceConfigureInternalAPIAPI_DeviceConfigInternalProvisionDevice_Call) RunAndReturn(run func(ctx context.Context, tenantId string) client.ApiDeviceConfigInternalProvisionDeviceRequest) *MockDeviceConfigureInternalAPIAPI_DeviceConfigInternalProvisionDevice_Call {
	_c.Call.Return(run)
	return _c
}

// DeviceConfigInternalProvisionDeviceExecute provides a mock function for the type MockDeviceConfigureInternalAPIAPI
func (_mock *MockDeviceConfigureInternalAPIAPI) DeviceConfigInternalProvisionDeviceExecute(r client.ApiDeviceConfigInternalProvisionDeviceRequest) (*http.Response, error) {
	ret := _mock.Called(r)

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

	var r0 *http.Response
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(client.ApiDeviceConfigInternalProvisionDeviceRequest) (*http.Response, error)); ok {
		return returnFunc(r)
	}
	if returnFunc, ok := ret.Get(0).(func(client.ApiDeviceConfigInternalProvisionDeviceRequest) *http.Response); ok {
		r0 = returnFunc(r)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*http.Response)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(client.ApiDeviceConfigInternalProvisionDeviceRequest) error); ok {
		r1 = returnFunc(r)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// DeviceConfigInternalProvisionDeviceExecute is a helper method to define mock.On call
//   - r client.ApiDeviceConfigInternalProvisionDeviceRequest
func (_e *MockDeviceConfigureInternalAPIAPI_Expecter) DeviceConfigInternalProvisionDeviceExecute(r interface{}) *MockDeviceConfigureInternalAPIAPI_DeviceConfigInternalProvisionDeviceExecute_Call {
	return &MockDeviceConfigureInternalAPIAPI_DeviceConfigInternalProvisionDeviceExecute_Call{Call: _e.mock.On("DeviceConfigInternalProvisionDeviceExecute", r)}
}

func (_c *MockDeviceConfigureInternalAPIAPI_DeviceConfigInternalProvisionDeviceExecute_Call) Run(run func(r client.ApiDeviceConfigInternalProvisionDeviceRequest)) *MockDeviceConfigureInternalAPIAPI_DeviceConfigInternalProvisionDeviceExecute_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 client.ApiDeviceConfigInternalProvisionDeviceRequest
		if args[0] != nil {
			arg0 = args[0].(client.ApiDeviceConfigInternalProvisionDeviceRequest)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *MockDeviceConfigureInternalAPIAPI_DeviceConfigInternalProvisionDeviceExecute_Call) Return(response *http.Response, err error) *MockDeviceConfigureInternalAPIAPI_DeviceConfigInternalProvisionDeviceExecute_Call {
	_c.Call.Return(response, err)
	return _c
}

func (_c *MockDeviceConfigureInternalAPIAPI_DeviceConfigInternalProvisionDeviceExecute_Call) RunAndReturn(run func(r client.ApiDeviceConfigInternalProvisionDeviceRequest) (*http.Response, error)) *MockDeviceConfigureInternalAPIAPI_DeviceConfigInternalProvisionDeviceExecute_Call {
	_c.Call.Return(run)
	return _c
}

// DeviceConfigInternalProvisionTenant provides a mock function for the type MockDeviceConfigureInternalAPIAPI
func (_mock *MockDeviceConfigureInternalAPIAPI) DeviceConfigInternalProvisionTenant(ctx context.Context) client.ApiDeviceConfigInternalProvisionTenantRequest {
	ret := _mock.Called(ctx)

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

	var r0 client.ApiDeviceConfigInternalProvisionTenantRequest
	if returnFunc, ok := ret.Get(0).(func(context.Context) client.ApiDeviceConfigInternalProvisionTenantRequest); ok {
		r0 = returnFunc(ctx)
	} else {
		r0 = ret.Get(0).(client.ApiDeviceConfigInternalProvisionTenantRequest)
	}
	return r0
}

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

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

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

func (_c *MockDeviceConfigureInternalAPIAPI_DeviceConfigInternalProvisionTenant_Call) Return(apiDeviceConfigInternalProvisionTenantRequest client.ApiDeviceConfigInternalProvisionTenantRequest) *MockDeviceConfigureInternalAPIAPI_DeviceConfigInternalProvisionTenant_Call {
	_c.Call.Return(apiDeviceConfigInternalProvisionTenantRequest)
	return _c
}

func (_c *MockDeviceConfigureInternalAPIAPI_DeviceConfigInternalProvisionTenant_Call) RunAndReturn(run func(ctx context.Context) client.ApiDeviceConfigInternalProvisionTenantRequest) *MockDeviceConfigureInternalAPIAPI_DeviceConfigInternalProvisionTenant_Call {
	_c.Call.Return(run)
	return _c
}

// DeviceConfigInternalProvisionTenantExecute provides a mock function for the type MockDeviceConfigureInternalAPIAPI
func (_mock *MockDeviceConfigureInternalAPIAPI) DeviceConfigInternalProvisionTenantExecute(r client.ApiDeviceConfigInternalProvisionTenantRequest) (*http.Response, error) {
	ret := _mock.Called(r)

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

	var r0 *http.Response
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(client.ApiDeviceConfigInternalProvisionTenantRequest) (*http.Response, error)); ok {
		return returnFunc(r)
	}
	if returnFunc, ok := ret.Get(0).(func(client.ApiDeviceConfigInternalProvisionTenantRequest) *http.Response); ok {
		r0 = returnFunc(r)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*http.Response)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(client.ApiDeviceConfigInternalProvisionTenantRequest) error); ok {
		r1 = returnFunc(r)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// DeviceConfigInternalProvisionTenantExecute is a helper method to define mock.On call
//   - r client.ApiDeviceConfigInternalProvisionTenantRequest
func (_e *MockDeviceConfigureInternalAPIAPI_Expecter) DeviceConfigInternalProvisionTenantExecute(r interface{}) *MockDeviceConfigureInternalAPIAPI_DeviceConfigInternalProvisionTenantExecute_Call {
	return &MockDeviceConfigureInternalAPIAPI_DeviceConfigInternalProvisionTenantExecute_Call{Call: _e.mock.On("DeviceConfigInternalProvisionTenantExecute", r)}
}

func (_c *MockDeviceConfigureInternalAPIAPI_DeviceConfigInternalProvisionTenantExecute_Call) Run(run func(r client.ApiDeviceConfigInternalProvisionTenantRequest)) *MockDeviceConfigureInternalAPIAPI_DeviceConfigInternalProvisionTenantExecute_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 client.ApiDeviceConfigInternalProvisionTenantRequest
		if args[0] != nil {
			arg0 = args[0].(client.ApiDeviceConfigInternalProvisionTenantRequest)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *MockDeviceConfigureInternalAPIAPI_DeviceConfigInternalProvisionTenantExecute_Call) Return(response *http.Response, err error) *MockDeviceConfigureInternalAPIAPI_DeviceConfigInternalProvisionTenantExecute_Call {
	_c.Call.Return(response, err)
	return _c
}

func (_c *MockDeviceConfigureInternalAPIAPI_DeviceConfigInternalProvisionTenantExecute_Call) RunAndReturn(run func(r client.ApiDeviceConfigInternalProvisionTenantRequest) (*http.Response, error)) *MockDeviceConfigureInternalAPIAPI_DeviceConfigInternalProvisionTenantExecute_Call {
	_c.Call.Return(run)
	return _c
}

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

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

	return mock
}

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

type MockDeviceConfigureManagementAPIAPI_Expecter struct {
	mock *mock.Mock
}

func (_m *MockDeviceConfigureManagementAPIAPI) EXPECT() *MockDeviceConfigureManagementAPIAPI_Expecter {
	return &MockDeviceConfigureManagementAPIAPI_Expecter{mock: &_m.Mock}
}

// DeviceConfigManagementDeployDeviceConfiguration provides a mock function for the type MockDeviceConfigureManagementAPIAPI
func (_mock *MockDeviceConfigureManagementAPIAPI) DeviceConfigManagementDeployDeviceConfiguration(ctx context.Context, deviceId string) client.ApiDeviceConfigManagementDeployDeviceConfigurationRequest {
	ret := _mock.Called(ctx, deviceId)

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

	var r0 client.ApiDeviceConfigManagementDeployDeviceConfigurationRequest
	if returnFunc, ok := ret.Get(0).(func(context.Context, string) client.ApiDeviceConfigManagementDeployDeviceConfigurationRequest); ok {
		r0 = returnFunc(ctx, deviceId)
	} else {
		r0 = ret.Get(0).(client.ApiDeviceConfigManagementDeployDeviceConfigurationRequest)
	}
	return r0
}

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

// DeviceConfigManagementDeployDeviceConfiguration is a helper method to define mock.On call
//   - ctx context.Context
//   - deviceId string
func (_e *MockDeviceConfigureManagementAPIAPI_Expecter) DeviceConfigManagementDeployDeviceConfiguration(ctx interface{}, deviceId interface{}) *MockDeviceConfigureManagementAPIAPI_DeviceConfigManagementDeployDeviceConfiguration_Call {
	return &MockDeviceConfigureManagementAPIAPI_DeviceConfigManagementDeployDeviceConfiguration_Call{Call: _e.mock.On("DeviceConfigManagementDeployDeviceConfiguration", ctx, deviceId)}
}

func (_c *MockDeviceConfigureManagementAPIAPI_DeviceConfigManagementDeployDeviceConfiguration_Call) Run(run func(ctx context.Context, deviceId string)) *MockDeviceConfigureManagementAPIAPI_DeviceConfigManagementDeployDeviceConfiguration_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 *MockDeviceConfigureManagementAPIAPI_DeviceConfigManagementDeployDeviceConfiguration_Call) Return(apiDeviceConfigManagementDeployDeviceConfigurationRequest client.ApiDeviceConfigManagementDeployDeviceConfigurationRequest) *MockDeviceConfigureManagementAPIAPI_DeviceConfigManagementDeployDeviceConfiguration_Call {
	_c.Call.Return(apiDeviceConfigManagementDeployDeviceConfigurationRequest)
	return _c
}

func (_c *MockDeviceConfigureManagementAPIAPI_DeviceConfigManagementDeployDeviceConfiguration_Call) RunAndReturn(run func(ctx context.Context, deviceId string) client.ApiDeviceConfigManagementDeployDeviceConfigurationRequest) *MockDeviceConfigureManagementAPIAPI_DeviceConfigManagementDeployDeviceConfiguration_Call {
	_c.Call.Return(run)
	return _c
}

// DeviceConfigManagementDeployDeviceConfigurationExecute provides a mock function for the type MockDeviceConfigureManagementAPIAPI
func (_mock *MockDeviceConfigureManagementAPIAPI) DeviceConfigManagementDeployDeviceConfigurationExecute(r client.ApiDeviceConfigManagementDeployDeviceConfigurationRequest) (*client.NewConfigurationDeploymentResponse, *http.Response, error) {
	ret := _mock.Called(r)

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

	var r0 *client.NewConfigurationDeploymentResponse
	var r1 *http.Response
	var r2 error
	if returnFunc, ok := ret.Get(0).(func(client.ApiDeviceConfigManagementDeployDeviceConfigurationRequest) (*client.NewConfigurationDeploymentResponse, *http.Response, error)); ok {
		return returnFunc(r)
	}
	if returnFunc, ok := ret.Get(0).(func(client.ApiDeviceConfigManagementDeployDeviceConfigurationRequest) *client.NewConfigurationDeploymentResponse); ok {
		r0 = returnFunc(r)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*client.NewConfigurationDeploymentResponse)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(client.ApiDeviceConfigManagementDeployDeviceConfigurationRequest) *http.Response); ok {
		r1 = returnFunc(r)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*http.Response)
		}
	}
	if returnFunc, ok := ret.Get(2).(func(client.ApiDeviceConfigManagementDeployDeviceConfigurationRequest) error); ok {
		r2 = returnFunc(r)
	} else {
		r2 = ret.Error(2)
	}
	return r0, r1, r2
}

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

// DeviceConfigManagementDeployDeviceConfigurationExecute is a helper method to define mock.On call
//   - r client.ApiDeviceConfigManagementDeployDeviceConfigurationRequest
func (_e *MockDeviceConfigureManagementAPIAPI_Expecter) DeviceConfigManagementDeployDeviceConfigurationExecute(r interface{}) *MockDeviceConfigureManagementAPIAPI_DeviceConfigManagementDeployDeviceConfigurationExecute_Call {
	return &MockDeviceConfigureManagementAPIAPI_DeviceConfigManagementDeployDeviceConfigurationExecute_Call{Call: _e.mock.On("DeviceConfigManagementDeployDeviceConfigurationExecute", r)}
}

func (_c *MockDeviceConfigureManagementAPIAPI_DeviceConfigManagementDeployDeviceConfigurationExecute_Call) Run(run func(r client.ApiDeviceConfigManagementDeployDeviceConfigurationRequest)) *MockDeviceConfigureManagementAPIAPI_DeviceConfigManagementDeployDeviceConfigurationExecute_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 client.ApiDeviceConfigManagementDeployDeviceConfigurationRequest
		if args[0] != nil {
			arg0 = args[0].(client.ApiDeviceConfigManagementDeployDeviceConfigurationRequest)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *MockDeviceConfigureManagementAPIAPI_DeviceConfigManagementDeployDeviceConfigurationExecute_Call) Return(newConfigurationDeploymentResponse *client.NewConfigurationDeploymentResponse, response *http.Response, err error) *MockDeviceConfigureManagementAPIAPI_DeviceConfigManagementDeployDeviceConfigurationExecute_Call {
	_c.Call.Return(newConfigurationDeploymentResponse, response, err)
	return _c
}

func (_c *MockDeviceConfigureManagementAPIAPI_DeviceConfigManagementDeployDeviceConfigurationExecute_Call) RunAndReturn(run func(r client.ApiDeviceConfigManagementDeployDeviceConfigurationRequest) (*client.NewConfigurationDeploymentResponse, *http.Response, error)) *MockDeviceConfigureManagementAPIAPI_DeviceConfigManagementDeployDeviceConfigurationExecute_Call {
	_c.Call.Return(run)
	return _c
}

// DeviceConfigManagementGetDeviceConfiguration provides a mock function for the type MockDeviceConfigureManagementAPIAPI
func (_mock *MockDeviceConfigureManagementAPIAPI) DeviceConfigManagementGetDeviceConfiguration(ctx context.Context, deviceId string) client.ApiDeviceConfigManagementGetDeviceConfigurationRequest {
	ret := _mock.Called(ctx, deviceId)

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

	var r0 client.ApiDeviceConfigManagementGetDeviceConfigurationRequest
	if returnFunc, ok := ret.Get(0).(func(context.Context, string) client.ApiDeviceConfigManagementGetDeviceConfigurationRequest); ok {
		r0 = returnFunc(ctx, deviceId)
	} else {
		r0 = ret.Get(0).(client.ApiDeviceConfigManagementGetDeviceConfigurationRequest)
	}
	return r0
}

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

// DeviceConfigManagementGetDeviceConfiguration is a helper method to define mock.On call
//   - ctx context.Context
//   - deviceId string
func (_e *MockDeviceConfigureManagementAPIAPI_Expecter) DeviceConfigManagementGetDeviceConfiguration(ctx interface{}, deviceId interface{}) *MockDeviceConfigureManagementAPIAPI_DeviceConfigManagementGetDeviceConfiguration_Call {
	return &MockDeviceConfigureManagementAPIAPI_DeviceConfigManagementGetDeviceConfiguration_Call{Call: _e.mock.On("DeviceConfigManagementGetDeviceConfiguration", ctx, deviceId)}
}

func (_c *MockDeviceConfigureManagementAPIAPI_DeviceConfigManagementGetDeviceConfiguration_Call) Run(run func(ctx context.Context, deviceId string)) *MockDeviceConfigureManagementAPIAPI_DeviceConfigManagementGetDeviceConfiguration_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 *MockDeviceConfigureManagementAPIAPI_DeviceConfigManagementGetDeviceConfiguration_Call) Return(apiDeviceConfigManagementGetDeviceConfigurationRequest client.ApiDeviceConfigManagementGetDeviceConfigurationRequest) *MockDeviceConfigureManagementAPIAPI_DeviceConfigManagementGetDeviceConfiguration_Call {
	_c.Call.Return(apiDeviceConfigManagementGetDeviceConfigurationRequest)
	return _c
}

func (_c *MockDeviceConfigureManagementAPIAPI_DeviceConfigManagementGetDeviceConfiguration_Call) RunAndReturn(run func(ctx context.Context, deviceId string) client.ApiDeviceConfigManagementGetDeviceConfigurationRequest) *MockDeviceConfigureManagementAPIAPI_DeviceConfigManagementGetDeviceConfiguration_Call {
	_c.Call.Return(run)
	return _c
}

// DeviceConfigManagementGetDeviceConfigurationExecute provides a mock function for the type MockDeviceConfigureManagementAPIAPI
func (_mock *MockDeviceConfigureManagementAPIAPI) DeviceConfigManagementGetDeviceConfigurationExecute(r client.ApiDeviceConfigManagementGetDeviceConfigurationRequest) (*client.DeviceConfiguration, *http.Response, error) {
	ret := _mock.Called(r)

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

	var r0 *client.DeviceConfiguration
	var r1 *http.Response
	var r2 error
	if returnFunc, ok := ret.Get(0).(func(client.ApiDeviceConfigManagementGetDeviceConfigurationRequest) (*client.DeviceConfiguration, *http.Response, error)); ok {
		return returnFunc(r)
	}
	if returnFunc, ok := ret.Get(0).(func(client.ApiDeviceConfigManagementGetDeviceConfigurationRequest) *client.DeviceConfiguration); ok {
		r0 = returnFunc(r)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*client.DeviceConfiguration)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(client.ApiDeviceConfigManagementGetDeviceConfigurationRequest) *http.Response); ok {
		r1 = returnFunc(r)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*http.Response)
		}
	}
	if returnFunc, ok := ret.Get(2).(func(client.ApiDeviceConfigManagementGetDeviceConfigurationRequest) error); ok {
		r2 = returnFunc(r)
	} else {
		r2 = ret.Error(2)
	}
	return r0, r1, r2
}

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

// DeviceConfigManagementGetDeviceConfigurationExecute is a helper method to define mock.On call
//   - r client.ApiDeviceConfigManagementGetDeviceConfigurationRequest
func (_e *MockDeviceConfigureManagementAPIAPI_Expecter) DeviceConfigManagementGetDeviceConfigurationExecute(r interface{}) *MockDeviceConfigureManagementAPIAPI_DeviceConfigManagementGetDeviceConfigurationExecute_Call {
	return &MockDeviceConfigureManagementAPIAPI_DeviceConfigManagementGetDeviceConfigurationExecute_Call{Call: _e.mock.On("DeviceConfigManagementGetDeviceConfigurationExecute", r)}
}

func (_c *MockDeviceConfigureManagementAPIAPI_DeviceConfigManagementGetDeviceConfigurationExecute_Call) Run(run func(r client.ApiDeviceConfigManagementGetDeviceConfigurationRequest)) *MockDeviceConfigureManagementAPIAPI_DeviceConfigManagementGetDeviceConfigurationExecute_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 client.ApiDeviceConfigManagementGetDeviceConfigurationRequest
		if args[0] != nil {
			arg0 = args[0].(client.ApiDeviceConfigManagementGetDeviceConfigurationRequest)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *MockDeviceConfigureManagementAPIAPI_DeviceConfigManagementGetDeviceConfigurationExecute_Call) Return(deviceConfiguration *client.DeviceConfiguration, response *http.Response, err error) *MockDeviceConfigureManagementAPIAPI_DeviceConfigManagementGetDeviceConfigurationExecute_Call {
	_c.Call.Return(deviceConfiguration, response, err)
	return _c
}

func (_c *MockDeviceConfigureManagementAPIAPI_DeviceConfigManagementGetDeviceConfigurationExecute_Call) RunAndReturn(run func(r client.ApiDeviceConfigManagementGetDeviceConfigurationRequest) (*client.DeviceConfiguration, *http.Response, error)) *MockDeviceConfigureManagementAPIAPI_DeviceConfigManagementGetDeviceConfigurationExecute_Call {
	_c.Call.Return(run)
	return _c
}

// DeviceConfigManagementSetDeviceConfiguration provides a mock function for the type MockDeviceConfigureManagementAPIAPI
func (_mock *MockDeviceConfigureManagementAPIAPI) DeviceConfigManagementSetDeviceConfiguration(ctx context.Context, deviceId string) client.ApiDeviceConfigManagementSetDeviceConfigurationRequest {
	ret := _mock.Called(ctx, deviceId)

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

	var r0 client.ApiDeviceConfigManagementSetDeviceConfigurationRequest
	if returnFunc, ok := ret.Get(0).(func(context.Context, string) client.ApiDeviceConfigManagementSetDeviceConfigurationRequest); ok {
		r0 = returnFunc(ctx, deviceId)
	} else {
		r0 = ret.Get(0).(client.ApiDeviceConfigManagementSetDeviceConfigurationRequest)
	}
	return r0
}

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

// DeviceConfigManagementSetDeviceConfiguration is a helper method to define mock.On call
//   - ctx context.Context
//   - deviceId string
func (_e *MockDeviceConfigureManagementAPIAPI_Expecter) DeviceConfigManagementSetDeviceConfiguration(ctx interface{}, deviceId interface{}) *MockDeviceConfigureManagementAPIAPI_DeviceConfigManagementSetDeviceConfiguration_Call {
	return &MockDeviceConfigureManagementAPIAPI_DeviceConfigManagementSetDeviceConfiguration_Call{Call: _e.mock.On("DeviceConfigManagementSetDeviceConfiguration", ctx, deviceId)}
}

func (_c *MockDeviceConfigureManagementAPIAPI_DeviceConfigManagementSetDeviceConfiguration_Call) Run(run func(ctx context.Context, deviceId string)) *MockDeviceConfigureManagementAPIAPI_DeviceConfigManagementSetDeviceConfiguration_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 *MockDeviceConfigureManagementAPIAPI_DeviceConfigManagementSetDeviceConfiguration_Call) Return(apiDeviceConfigManagementSetDeviceConfigurationRequest client.ApiDeviceConfigManagementSetDeviceConfigurationRequest) *MockDeviceConfigureManagementAPIAPI_DeviceConfigManagementSetDeviceConfiguration_Call {
	_c.Call.Return(apiDeviceConfigManagementSetDeviceConfigurationRequest)
	return _c
}

func (_c *MockDeviceConfigureManagementAPIAPI_DeviceConfigManagementSetDeviceConfiguration_Call) RunAndReturn(run func(ctx context.Context, deviceId string) client.ApiDeviceConfigManagementSetDeviceConfigurationRequest) *MockDeviceConfigureManagementAPIAPI_DeviceConfigManagementSetDeviceConfiguration_Call {
	_c.Call.Return(run)
	return _c
}

// DeviceConfigManagementSetDeviceConfigurationExecute provides a mock function for the type MockDeviceConfigureManagementAPIAPI
func (_mock *MockDeviceConfigureManagementAPIAPI) DeviceConfigManagementSetDeviceConfigurationExecute(r client.ApiDeviceConfigManagementSetDeviceConfigurationRequest) (*http.Response, error) {
	ret := _mock.Called(r)

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

	var r0 *http.Response
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(client.ApiDeviceConfigManagementSetDeviceConfigurationRequest) (*http.Response, error)); ok {
		return returnFunc(r)
	}
	if returnFunc, ok := ret.Get(0).(func(client.ApiDeviceConfigManagementSetDeviceConfigurationRequest) *http.Response); ok {
		r0 = returnFunc(r)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*http.Response)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(client.ApiDeviceConfigManagementSetDeviceConfigurationRequest) error); ok {
		r1 = returnFunc(r)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// DeviceConfigManagementSetDeviceConfigurationExecute is a helper method to define mock.On call
//   - r client.ApiDeviceConfigManagementSetDeviceConfigurationRequest
func (_e *MockDeviceConfigureManagementAPIAPI_Expecter) DeviceConfigManagementSetDeviceConfigurationExecute(r interface{}) *MockDeviceConfigureManagementAPIAPI_DeviceConfigManagementSetDeviceConfigurationExecute_Call {
	return &MockDeviceConfigureManagementAPIAPI_DeviceConfigManagementSetDeviceConfigurationExecute_Call{Call: _e.mock.On("DeviceConfigManagementSetDeviceConfigurationExecute", r)}
}

func (_c *MockDeviceConfigureManagementAPIAPI_DeviceConfigManagementSetDeviceConfigurationExecute_Call) Run(run func(r client.ApiDeviceConfigManagementSetDeviceConfigurationRequest)) *MockDeviceConfigureManagementAPIAPI_DeviceConfigManagementSetDeviceConfigurationExecute_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 client.ApiDeviceConfigManagementSetDeviceConfigurationRequest
		if args[0] != nil {
			arg0 = args[0].(client.ApiDeviceConfigManagementSetDeviceConfigurationRequest)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *MockDeviceConfigureManagementAPIAPI_DeviceConfigManagementSetDeviceConfigurationExecute_Call) Return(response *http.Response, err error) *MockDeviceConfigureManagementAPIAPI_DeviceConfigManagementSetDeviceConfigurationExecute_Call {
	_c.Call.Return(response, err)
	return _c
}

func (_c *MockDeviceConfigureManagementAPIAPI_DeviceConfigManagementSetDeviceConfigurationExecute_Call) RunAndReturn(run func(r client.ApiDeviceConfigManagementSetDeviceConfigurationRequest) (*http.Response, error)) *MockDeviceConfigureManagementAPIAPI_DeviceConfigManagementSetDeviceConfigurationExecute_Call {
	_c.Call.Return(run)
	return _c
}

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

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

	return mock
}

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

type MockDeviceConnectDeviceAPIAPI_Expecter struct {
	mock *mock.Mock
}

func (_m *MockDeviceConnectDeviceAPIAPI) EXPECT() *MockDeviceConnectDeviceAPIAPI_Expecter {
	return &MockDeviceConnectDeviceAPIAPI_Expecter{mock: &_m.Mock}
}

// DeviceConnectConnect provides a mock function for the type MockDeviceConnectDeviceAPIAPI
func (_mock *MockDeviceConnectDeviceAPIAPI) DeviceConnectConnect(ctx context.Context) client.ApiDeviceConnectConnectRequest {
	ret := _mock.Called(ctx)

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

	var r0 client.ApiDeviceConnectConnectRequest
	if returnFunc, ok := ret.Get(0).(func(context.Context) client.ApiDeviceConnectConnectRequest); ok {
		r0 = returnFunc(ctx)
	} else {
		r0 = ret.Get(0).(client.ApiDeviceConnectConnectRequest)
	}
	return r0
}

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

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

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

func (_c *MockDeviceConnectDeviceAPIAPI_DeviceConnectConnect_Call) Return(apiDeviceConnectConnectRequest client.ApiDeviceConnectConnectRequest) *MockDeviceConnectDeviceAPIAPI_DeviceConnectConnect_Call {
	_c.Call.Return(apiDeviceConnectConnectRequest)
	return _c
}

func (_c *MockDeviceConnectDeviceAPIAPI_DeviceConnectConnect_Call) RunAndReturn(run func(ctx context.Context) client.ApiDeviceConnectConnectRequest) *MockDeviceConnectDeviceAPIAPI_DeviceConnectConnect_Call {
	_c.Call.Return(run)
	return _c
}

// DeviceConnectConnectExecute provides a mock function for the type MockDeviceConnectDeviceAPIAPI
func (_mock *MockDeviceConnectDeviceAPIAPI) DeviceConnectConnectExecute(r client.ApiDeviceConnectConnectRequest) (*http.Response, error) {
	ret := _mock.Called(r)

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

	var r0 *http.Response
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(client.ApiDeviceConnectConnectRequest) (*http.Response, error)); ok {
		return returnFunc(r)
	}
	if returnFunc, ok := ret.Get(0).(func(client.ApiDeviceConnectConnectRequest) *http.Response); ok {
		r0 = returnFunc(r)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*http.Response)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(client.ApiDeviceConnectConnectRequest) error); ok {
		r1 = returnFunc(r)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// DeviceConnectConnectExecute is a helper method to define mock.On call
//   - r client.ApiDeviceConnectConnectRequest
func (_e *MockDeviceConnectDeviceAPIAPI_Expecter) DeviceConnectConnectExecute(r interface{}) *MockDeviceConnectDeviceAPIAPI_DeviceConnectConnectExecute_Call {
	return &MockDeviceConnectDeviceAPIAPI_DeviceConnectConnectExecute_Call{Call: _e.mock.On("DeviceConnectConnectExecute", r)}
}

func (_c *MockDeviceConnectDeviceAPIAPI_DeviceConnectConnectExecute_Call) Run(run func(r client.ApiDeviceConnectConnectRequest)) *MockDeviceConnectDeviceAPIAPI_DeviceConnectConnectExecute_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 client.ApiDeviceConnectConnectRequest
		if args[0] != nil {
			arg0 = args[0].(client.ApiDeviceConnectConnectRequest)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *MockDeviceConnectDeviceAPIAPI_DeviceConnectConnectExecute_Call) Return(response *http.Response, err error) *MockDeviceConnectDeviceAPIAPI_DeviceConnectConnectExecute_Call {
	_c.Call.Return(response, err)
	return _c
}

func (_c *MockDeviceConnectDeviceAPIAPI_DeviceConnectConnectExecute_Call) RunAndReturn(run func(r client.ApiDeviceConnectConnectRequest) (*http.Response, error)) *MockDeviceConnectDeviceAPIAPI_DeviceConnectConnectExecute_Call {
	_c.Call.Return(run)
	return _c
}

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

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

	return mock
}

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

type MockDeviceConnectInternalAPIAPI_Expecter struct {
	mock *mock.Mock
}

func (_m *MockDeviceConnectInternalAPIAPI) EXPECT() *MockDeviceConnectInternalAPIAPI_Expecter {
	return &MockDeviceConnectInternalAPIAPI_Expecter{mock: &_m.Mock}
}

// DeleteTenant provides a mock function for the type MockDeviceConnectInternalAPIAPI
func (_mock *MockDeviceConnectInternalAPIAPI) DeleteTenant(ctx context.Context, tenantId string) client.ApiDeleteTenantRequest {
	ret := _mock.Called(ctx, tenantId)

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

	var r0 client.ApiDeleteTenantRequest
	if returnFunc, ok := ret.Get(0).(func(context.Context, string) client.ApiDeleteTenantRequest); ok {
		r0 = returnFunc(ctx, tenantId)
	} else {
		r0 = ret.Get(0).(client.ApiDeleteTenantRequest)
	}
	return r0
}

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

// DeleteTenant is a helper method to define mock.On call
//   - ctx context.Context
//   - tenantId string
func (_e *MockDeviceConnectInternalAPIAPI_Expecter) DeleteTenant(ctx interface{}, tenantId interface{}) *MockDeviceConnectInternalAPIAPI_DeleteTenant_Call {
	return &MockDeviceConnectInternalAPIAPI_DeleteTenant_Call{Call: _e.mock.On("DeleteTenant", ctx, tenantId)}
}

func (_c *MockDeviceConnectInternalAPIAPI_DeleteTenant_Call) Run(run func(ctx context.Context, tenantId string)) *MockDeviceConnectInternalAPIAPI_DeleteTenant_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 *MockDeviceConnectInternalAPIAPI_DeleteTenant_Call) Return(apiDeleteTenantRequest client.ApiDeleteTenantRequest) *MockDeviceConnectInternalAPIAPI_DeleteTenant_Call {
	_c.Call.Return(apiDeleteTenantRequest)
	return _c
}

func (_c *MockDeviceConnectInternalAPIAPI_DeleteTenant_Call) RunAndReturn(run func(ctx context.Context, tenantId string) client.ApiDeleteTenantRequest) *MockDeviceConnectInternalAPIAPI_DeleteTenant_Call {
	_c.Call.Return(run)
	return _c
}

// DeleteTenantExecute provides a mock function for the type MockDeviceConnectInternalAPIAPI
func (_mock *MockDeviceConnectInternalAPIAPI) DeleteTenantExecute(r client.ApiDeleteTenantRequest) (*http.Response, error) {
	ret := _mock.Called(r)

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

	var r0 *http.Response
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(client.ApiDeleteTenantRequest) (*http.Response, error)); ok {
		return returnFunc(r)
	}
	if returnFunc, ok := ret.Get(0).(func(client.ApiDeleteTenantRequest) *http.Response); ok {
		r0 = returnFunc(r)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*http.Response)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(client.ApiDeleteTenantRequest) error); ok {
		r1 = returnFunc(r)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// DeleteTenantExecute is a helper method to define mock.On call
//   - r client.ApiDeleteTenantRequest
func (_e *MockDeviceConnectInternalAPIAPI_Expecter) DeleteTenantExecute(r interface{}) *MockDeviceConnectInternalAPIAPI_DeleteTenantExecute_Call {
	return &MockDeviceConnectInternalAPIAPI_DeleteTenantExecute_Call{Call: _e.mock.On("DeleteTenantExecute", r)}
}

func (_c *MockDeviceConnectInternalAPIAPI_DeleteTenantExecute_Call) Run(run func(r client.ApiDeleteTenantRequest)) *MockDeviceConnectInternalAPIAPI_DeleteTenantExecute_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 client.ApiDeleteTenantRequest
		if args[0] != nil {
			arg0 = args[0].(client.ApiDeleteTenantRequest)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *MockDeviceConnectInternalAPIAPI_DeleteTenantExecute_Call) Return(response *http.Response, err error) *MockDeviceConnectInternalAPIAPI_DeleteTenantExecute_Call {
	_c.Call.Return(response, err)
	return _c
}

func (_c *MockDeviceConnectInternalAPIAPI_DeleteTenantExecute_Call) RunAndReturn(run func(r client.ApiDeleteTenantRequest) (*http.Response, error)) *MockDeviceConnectInternalAPIAPI_DeleteTenantExecute_Call {
	_c.Call.Return(run)
	return _c
}

// DeviceConnectInternalCheckHealth provides a mock function for the type MockDeviceConnectInternalAPIAPI
func (_mock *MockDeviceConnectInternalAPIAPI) DeviceConnectInternalCheckHealth(ctx context.Context) client.ApiDeviceConnectInternalCheckHealthRequest {
	ret := _mock.Called(ctx)

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

	var r0 client.ApiDeviceConnectInternalCheckHealthRequest
	if returnFunc, ok := ret.Get(0).(func(context.Context) client.ApiDeviceConnectInternalCheckHealthRequest); ok {
		r0 = returnFunc(ctx)
	} else {
		r0 = ret.Get(0).(client.ApiDeviceConnectInternalCheckHealthRequest)
	}
	return r0
}

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

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

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

func (_c *MockDeviceConnectInternalAPIAPI_DeviceConnectInternalCheckHealth_Call) Return(apiDeviceConnectInternalCheckHealthRequest client.ApiDeviceConnectInternalCheckHealthRequest) *MockDeviceConnectInternalAPIAPI_DeviceConnectInternalCheckHealth_Call {
	_c.Call.Return(apiDeviceConnectInternalCheckHealthRequest)
	return _c
}

func (_c *MockDeviceConnectInternalAPIAPI_DeviceConnectInternalCheckHealth_Call) RunAndReturn(run func(ctx context.Context) client.ApiDeviceConnectInternalCheckHealthRequest) *MockDeviceConnectInternalAPIAPI_DeviceConnectInternalCheckHealth_Call {
	_c.Call.Return(run)
	return _c
}

// DeviceConnectInternalCheckHealthExecute provides a mock function for the type MockDeviceConnectInternalAPIAPI
func (_mock *MockDeviceConnectInternalAPIAPI) DeviceConnectInternalCheckHealthExecute(r client.ApiDeviceConnectInternalCheckHealthRequest) (*http.Response, error) {
	ret := _mock.Called(r)

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

	var r0 *http.Response
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(client.ApiDeviceConnectInternalCheckHealthRequest) (*http.Response, error)); ok {
		return returnFunc(r)
	}
	if returnFunc, ok := ret.Get(0).(func(client.ApiDeviceConnectInternalCheckHealthRequest) *http.Response); ok {
		r0 = returnFunc(r)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*http.Response)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(client.ApiDeviceConnectInternalCheckHealthRequest) error); ok {
		r1 = returnFunc(r)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// DeviceConnectInternalCheckHealthExecute is a helper method to define mock.On call
//   - r client.ApiDeviceConnectInternalCheckHealthRequest
func (_e *MockDeviceConnectInternalAPIAPI_Expecter) DeviceConnectInternalCheckHealthExecute(r interface{}) *MockDeviceConnectInternalAPIAPI_DeviceConnectInternalCheckHealthExecute_Call {
	return &MockDeviceConnectInternalAPIAPI_DeviceConnectInternalCheckHealthExecute_Call{Call: _e.mock.On("DeviceConnectInternalCheckHealthExecute", r)}
}

func (_c *MockDeviceConnectInternalAPIAPI_DeviceConnectInternalCheckHealthExecute_Call) Run(run func(r client.ApiDeviceConnectInternalCheckHealthRequest)) *MockDeviceConnectInternalAPIAPI_DeviceConnectInternalCheckHealthExecute_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 client.ApiDeviceConnectInternalCheckHealthRequest
		if args[0] != nil {
			arg0 = args[0].(client.ApiDeviceConnectInternalCheckHealthRequest)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *MockDeviceConnectInternalAPIAPI_DeviceConnectInternalCheckHealthExecute_Call) Return(response *http.Response, err error) *MockDeviceConnectInternalAPIAPI_DeviceConnectInternalCheckHealthExecute_Call {
	_c.Call.Return(response, err)
	return _c
}

func (_c *MockDeviceConnectInternalAPIAPI_DeviceConnectInternalCheckHealthExecute_Call) RunAndReturn(run func(r client.ApiDeviceConnectInternalCheckHealthRequest) (*http.Response, error)) *MockDeviceConnectInternalAPIAPI_DeviceConnectInternalCheckHealthExecute_Call {
	_c.Call.Return(run)
	return _c
}

// DeviceConnectInternalCheckLiveliness provides a mock function for the type MockDeviceConnectInternalAPIAPI
func (_mock *MockDeviceConnectInternalAPIAPI) DeviceConnectInternalCheckLiveliness(ctx context.Context) client.ApiDeviceConnectInternalCheckLivelinessRequest {
	ret := _mock.Called(ctx)

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

	var r0 client.ApiDeviceConnectInternalCheckLivelinessRequest
	if returnFunc, ok := ret.Get(0).(func(context.Context) client.ApiDeviceConnectInternalCheckLivelinessRequest); ok {
		r0 = returnFunc(ctx)
	} else {
		r0 = ret.Get(0).(client.ApiDeviceConnectInternalCheckLivelinessRequest)
	}
	return r0
}

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

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

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

func (_c *MockDeviceConnectInternalAPIAPI_DeviceConnectInternalCheckLiveliness_Call) Return(apiDeviceConnectInternalCheckLivelinessRequest client.ApiDeviceConnectInternalCheckLivelinessRequest) *MockDeviceConnectInternalAPIAPI_DeviceConnectInternalCheckLiveliness_Call {
	_c.Call.Return(apiDeviceConnectInternalCheckLivelinessRequest)
	return _c
}

func (_c *MockDeviceConnectInternalAPIAPI_DeviceConnectInternalCheckLiveliness_Call) RunAndReturn(run func(ctx context.Context) client.ApiDeviceConnectInternalCheckLivelinessRequest) *MockDeviceConnectInternalAPIAPI_DeviceConnectInternalCheckLiveliness_Call {
	_c.Call.Return(run)
	return _c
}

// DeviceConnectInternalCheckLivelinessExecute provides a mock function for the type MockDeviceConnectInternalAPIAPI
func (_mock *MockDeviceConnectInternalAPIAPI) DeviceConnectInternalCheckLivelinessExecute(r client.ApiDeviceConnectInternalCheckLivelinessRequest) (*http.Response, error) {
	ret := _mock.Called(r)

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

	var r0 *http.Response
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(client.ApiDeviceConnectInternalCheckLivelinessRequest) (*http.Response, error)); ok {
		return returnFunc(r)
	}
	if returnFunc, ok := ret.Get(0).(func(client.ApiDeviceConnectInternalCheckLivelinessRequest) *http.Response); ok {
		r0 = returnFunc(r)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*http.Response)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(client.ApiDeviceConnectInternalCheckLivelinessRequest) error); ok {
		r1 = returnFunc(r)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// DeviceConnectInternalCheckLivelinessExecute is a helper method to define mock.On call
//   - r client.ApiDeviceConnectInternalCheckLivelinessRequest
func (_e *MockDeviceConnectInternalAPIAPI_Expecter) DeviceConnectInternalCheckLivelinessExecute(r interface{}) *MockDeviceConnectInternalAPIAPI_DeviceConnectInternalCheckLivelinessExecute_Call {
	return &MockDeviceConnectInternalAPIAPI_DeviceConnectInternalCheckLivelinessExecute_Call{Call: _e.mock.On("DeviceConnectInternalCheckLivelinessExecute", r)}
}

func (_c *MockDeviceConnectInternalAPIAPI_DeviceConnectInternalCheckLivelinessExecute_Call) Run(run func(r client.ApiDeviceConnectInternalCheckLivelinessRequest)) *MockDeviceConnectInternalAPIAPI_DeviceConnectInternalCheckLivelinessExecute_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 client.ApiDeviceConnectInternalCheckLivelinessRequest
		if args[0] != nil {
			arg0 = args[0].(client.ApiDeviceConnectInternalCheckLivelinessRequest)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *MockDeviceConnectInternalAPIAPI_DeviceConnectInternalCheckLivelinessExecute_Call) Return(response *http.Response, err error) *MockDeviceConnectInternalAPIAPI_DeviceConnectInternalCheckLivelinessExecute_Call {
	_c.Call.Return(response, err)
	return _c
}

func (_c *MockDeviceConnectInternalAPIAPI_DeviceConnectInternalCheckLivelinessExecute_Call) RunAndReturn(run func(r client.ApiDeviceConnectInternalCheckLivelinessRequest) (*http.Response, error)) *MockDeviceConnectInternalAPIAPI_DeviceConnectInternalCheckLivelinessExecute_Call {
	_c.Call.Return(run)
	return _c
}

// DeviceConnectInternalCheckUpdate provides a mock function for the type MockDeviceConnectInternalAPIAPI
func (_mock *MockDeviceConnectInternalAPIAPI) DeviceConnectInternalCheckUpdate(ctx context.Context, tenantId string, deviceId string) client.ApiDeviceConnectInternalCheckUpdateRequest {
	ret := _mock.Called(ctx, tenantId, deviceId)

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

	var r0 client.ApiDeviceConnectInternalCheckUpdateRequest
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string) client.ApiDeviceConnectInternalCheckUpdateRequest); ok {
		r0 = returnFunc(ctx, tenantId, deviceId)
	} else {
		r0 = ret.Get(0).(client.ApiDeviceConnectInternalCheckUpdateRequest)
	}
	return r0
}

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

// DeviceConnectInternalCheckUpdate is a helper method to define mock.On call
//   - ctx context.Context
//   - tenantId string
//   - deviceId string
func (_e *MockDeviceConnectInternalAPIAPI_Expecter) DeviceConnectInternalCheckUpdate(ctx interface{}, tenantId interface{}, deviceId interface{}) *MockDeviceConnectInternalAPIAPI_DeviceConnectInternalCheckUpdate_Call {
	return &MockDeviceConnectInternalAPIAPI_DeviceConnectInternalCheckUpdate_Call{Call: _e.mock.On("DeviceConnectInternalCheckUpdate", ctx, tenantId, deviceId)}
}

func (_c *MockDeviceConnectInternalAPIAPI_DeviceConnectInternalCheckUpdate_Call) Run(run func(ctx context.Context, tenantId string, deviceId string)) *MockDeviceConnectInternalAPIAPI_DeviceConnectInternalCheckUpdate_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)
		}
		run(
			arg0,
			arg1,
			arg2,
		)
	})
	return _c
}

func (_c *MockDeviceConnectInternalAPIAPI_DeviceConnectInternalCheckUpdate_Call) Return(apiDeviceConnectInternalCheckUpdateRequest client.ApiDeviceConnectInternalCheckUpdateRequest) *MockDeviceConnectInternalAPIAPI_DeviceConnectInternalCheckUpdate_Call {
	_c.Call.Return(apiDeviceConnectInternalCheckUpdateRequest)
	return _c
}

func (_c *MockDeviceConnectInternalAPIAPI_DeviceConnectInternalCheckUpdate_Call) RunAndReturn(run func(ctx context.Context, tenantId string, deviceId string) client.ApiDeviceConnectInternalCheckUpdateRequest) *MockDeviceConnectInternalAPIAPI_DeviceConnectInternalCheckUpdate_Call {
	_c.Call.Return(run)
	return _c
}

// DeviceConnectInternalCheckUpdateExecute provides a mock function for the type MockDeviceConnectInternalAPIAPI
func (_mock *MockDeviceConnectInternalAPIAPI) DeviceConnectInternalCheckUpdateExecute(r client.ApiDeviceConnectInternalCheckUpdateRequest) (*http.Response, error) {
	ret := _mock.Called(r)

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

	var r0 *http.Response
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(client.ApiDeviceConnectInternalCheckUpdateRequest) (*http.Response, error)); ok {
		return returnFunc(r)
	}
	if returnFunc, ok := ret.Get(0).(func(client.ApiDeviceConnectInternalCheckUpdateRequest) *http.Response); ok {
		r0 = returnFunc(r)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*http.Response)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(client.ApiDeviceConnectInternalCheckUpdateRequest) error); ok {
		r1 = returnFunc(r)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// DeviceConnectInternalCheckUpdateExecute is a helper method to define mock.On call
//   - r client.ApiDeviceConnectInternalCheckUpdateRequest
func (_e *MockDeviceConnectInternalAPIAPI_Expecter) DeviceConnectInternalCheckUpdateExecute(r interface{}) *MockDeviceConnectInternalAPIAPI_DeviceConnectInternalCheckUpdateExecute_Call {
	return &MockDeviceConnectInternalAPIAPI_DeviceConnectInternalCheckUpdateExecute_Call{Call: _e.mock.On("DeviceConnectInternalCheckUpdateExecute", r)}
}

func (_c *MockDeviceConnectInternalAPIAPI_DeviceConnectInternalCheckUpdateExecute_Call) Run(run func(r client.ApiDeviceConnectInternalCheckUpdateRequest)) *MockDeviceConnectInternalAPIAPI_DeviceConnectInternalCheckUpdateExecute_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 client.ApiDeviceConnectInternalCheckUpdateRequest
		if args[0] != nil {
			arg0 = args[0].(client.ApiDeviceConnectInternalCheckUpdateRequest)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *MockDeviceConnectInternalAPIAPI_DeviceConnectInternalCheckUpdateExecute_Call) Return(response *http.Response, err error) *MockDeviceConnectInternalAPIAPI_DeviceConnectInternalCheckUpdateExecute_Call {
	_c.Call.Return(response, err)
	return _c
}

func (_c *MockDeviceConnectInternalAPIAPI_DeviceConnectInternalCheckUpdateExecute_Call) RunAndReturn(run func(r client.ApiDeviceConnectInternalCheckUpdateRequest) (*http.Response, error)) *MockDeviceConnectInternalAPIAPI_DeviceConnectInternalCheckUpdateExecute_Call {
	_c.Call.Return(run)
	return _c
}

// DeviceConnectInternalDecomissionDevice provides a mock function for the type MockDeviceConnectInternalAPIAPI
func (_mock *MockDeviceConnectInternalAPIAPI) DeviceConnectInternalDecomissionDevice(ctx context.Context, tenantId string, deviceId string) client.ApiDeviceConnectInternalDecomissionDeviceRequest {
	ret := _mock.Called(ctx, tenantId, deviceId)

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

	var r0 client.ApiDeviceConnectInternalDecomissionDeviceRequest
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string) client.ApiDeviceConnectInternalDecomissionDeviceRequest); ok {
		r0 = returnFunc(ctx, tenantId, deviceId)
	} else {
		r0 = ret.Get(0).(client.ApiDeviceConnectInternalDecomissionDeviceRequest)
	}
	return r0
}

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

// DeviceConnectInternalDecomissionDevice is a helper method to define mock.On call
//   - ctx context.Context
//   - tenantId string
//   - deviceId string
func (_e *MockDeviceConnectInternalAPIAPI_Expecter) DeviceConnectInternalDecomissionDevice(ctx interface{}, tenantId interface{}, deviceId interface{}) *MockDeviceConnectInternalAPIAPI_DeviceConnectInternalDecomissionDevice_Call {
	return &MockDeviceConnectInternalAPIAPI_DeviceConnectInternalDecomissionDevice_Call{Call: _e.mock.On("DeviceConnectInternalDecomissionDevice", ctx, tenantId, deviceId)}
}

func (_c *MockDeviceConnectInternalAPIAPI_DeviceConnectInternalDecomissionDevice_Call) Run(run func(ctx context.Context, tenantId string, deviceId string)) *MockDeviceConnectInternalAPIAPI_DeviceConnectInternalDecomissionDevice_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)
		}
		run(
			arg0,
			arg1,
			arg2,
		)
	})
	return _c
}

func (_c *MockDeviceConnectInternalAPIAPI_DeviceConnectInternalDecomissionDevice_Call) Return(apiDeviceConnectInternalDecomissionDeviceRequest client.ApiDeviceConnectInternalDecomissionDeviceRequest) *MockDeviceConnectInternalAPIAPI_DeviceConnectInternalDecomissionDevice_Call {
	_c.Call.Return(apiDeviceConnectInternalDecomissionDeviceRequest)
	return _c
}

func (_c *MockDeviceConnectInternalAPIAPI_DeviceConnectInternalDecomissionDevice_Call) RunAndReturn(run func(ctx context.Context, tenantId string, deviceId string) client.ApiDeviceConnectInternalDecomissionDeviceRequest) *MockDeviceConnectInternalAPIAPI_DeviceConnectInternalDecomissionDevice_Call {
	_c.Call.Return(run)
	return _c
}

// DeviceConnectInternalDecomissionDeviceExecute provides a mock function for the type MockDeviceConnectInternalAPIAPI
func (_mock *MockDeviceConnectInternalAPIAPI) DeviceConnectInternalDecomissionDeviceExecute(r client.ApiDeviceConnectInternalDecomissionDeviceRequest) (*http.Response, error) {
	ret := _mock.Called(r)

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

	var r0 *http.Response
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(client.ApiDeviceConnectInternalDecomissionDeviceRequest) (*http.Response, error)); ok {
		return returnFunc(r)
	}
	if returnFunc, ok := ret.Get(0).(func(client.ApiDeviceConnectInternalDecomissionDeviceRequest) *http.Response); ok {
		r0 = returnFunc(r)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*http.Response)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(client.ApiDeviceConnectInternalDecomissionDeviceRequest) error); ok {
		r1 = returnFunc(r)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// DeviceConnectInternalDecomissionDeviceExecute is a helper method to define mock.On call
//   - r client.ApiDeviceConnectInternalDecomissionDeviceRequest
func (_e *MockDeviceConnectInternalAPIAPI_Expecter) DeviceConnectInternalDecomissionDeviceExecute(r interface{}) *MockDeviceConnectInternalAPIAPI_DeviceConnectInternalDecomissionDeviceExecute_Call {
	return &MockDeviceConnectInternalAPIAPI_DeviceConnectInternalDecomissionDeviceExecute_Call{Call: _e.mock.On("DeviceConnectInternalDecomissionDeviceExecute", r)}
}

func (_c *MockDeviceConnectInternalAPIAPI_DeviceConnectInternalDecomissionDeviceExecute_Call) Run(run func(r client.ApiDeviceConnectInternalDecomissionDeviceRequest)) *MockDeviceConnectInternalAPIAPI_DeviceConnectInternalDecomissionDeviceExecute_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 client.ApiDeviceConnectInternalDecomissionDeviceRequest
		if args[0] != nil {
			arg0 = args[0].(client.ApiDeviceConnectInternalDecomissionDeviceRequest)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *MockDeviceConnectInternalAPIAPI_DeviceConnectInternalDecomissionDeviceExecute_Call) Return(response *http.Response, err error) *MockDeviceConnectInternalAPIAPI_DeviceConnectInternalDecomissionDeviceExecute_Call {
	_c.Call.Return(response, err)
	return _c
}

func (_c *MockDeviceConnectInternalAPIAPI_DeviceConnectInternalDecomissionDeviceExecute_Call) RunAndReturn(run func(r client.ApiDeviceConnectInternalDecomissionDeviceRequest) (*http.Response, error)) *MockDeviceConnectInternalAPIAPI_DeviceConnectInternalDecomissionDeviceExecute_Call {
	_c.Call.Return(run)
	return _c
}

// DeviceConnectInternalProvisionDevice provides a mock function for the type MockDeviceConnectInternalAPIAPI
func (_mock *MockDeviceConnectInternalAPIAPI) DeviceConnectInternalProvisionDevice(ctx context.Context, tenantId string) client.ApiDeviceConnectInternalProvisionDeviceRequest {
	ret := _mock.Called(ctx, tenantId)

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

	var r0 client.ApiDeviceConnectInternalProvisionDeviceRequest
	if returnFunc, ok := ret.Get(0).(func(context.Context, string) client.ApiDeviceConnectInternalProvisionDeviceRequest); ok {
		r0 = returnFunc(ctx, tenantId)
	} else {
		r0 = ret.Get(0).(client.ApiDeviceConnectInternalProvisionDeviceRequest)
	}
	return r0
}

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

// DeviceConnectInternalProvisionDevice is a helper method to define mock.On call
//   - ctx context.Context
//   - tenantId string
func (_e *MockDeviceConnectInternalAPIAPI_Expecter) DeviceConnectInternalProvisionDevice(ctx interface{}, tenantId interface{}) *MockDeviceConnectInternalAPIAPI_DeviceConnectInternalProvisionDevice_Call {
	return &MockDeviceConnectInternalAPIAPI_DeviceConnectInternalProvisionDevice_Call{Call: _e.mock.On("DeviceConnectInternalProvisionDevice", ctx, tenantId)}
}

func (_c *MockDeviceConnectInternalAPIAPI_DeviceConnectInternalProvisionDevice_Call) Run(run func(ctx context.Context, tenantId string)) *MockDeviceConnectInternalAPIAPI_DeviceConnectInternalProvisionDevice_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 *MockDeviceConnectInternalAPIAPI_DeviceConnectInternalProvisionDevice_Call) Return(apiDeviceConnectInternalProvisionDeviceRequest client.ApiDeviceConnectInternalProvisionDeviceRequest) *MockDeviceConnectInternalAPIAPI_DeviceConnectInternalProvisionDevice_Call {
	_c.Call.Return(apiDeviceConnectInternalProvisionDeviceRequest)
	return _c
}

func (_c *MockDeviceConnectInternalAPIAPI_DeviceConnectInternalProvisionDevice_Call) RunAndReturn(run func(ctx context.Context, tenantId string) client.ApiDeviceConnectInternalProvisionDeviceRequest) *MockDeviceConnectInternalAPIAPI_DeviceConnectInternalProvisionDevice_Call {
	_c.Call.Return(run)
	return _c
}

// DeviceConnectInternalProvisionDeviceExecute provides a mock function for the type MockDeviceConnectInternalAPIAPI
func (_mock *MockDeviceConnectInternalAPIAPI) DeviceConnectInternalProvisionDeviceExecute(r client.ApiDeviceConnectInternalProvisionDeviceRequest) (*http.Response, error) {
	ret := _mock.Called(r)

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

	var r0 *http.Response
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(client.ApiDeviceConnectInternalProvisionDeviceRequest) (*http.Response, error)); ok {
		return returnFunc(r)
	}
	if returnFunc, ok := ret.Get(0).(func(client.ApiDeviceConnectInternalProvisionDeviceRequest) *http.Response); ok {
		r0 = returnFunc(r)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*http.Response)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(client.ApiDeviceConnectInternalProvisionDeviceRequest) error); ok {
		r1 = returnFunc(r)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// DeviceConnectInternalProvisionDeviceExecute is a helper method to define mock.On call
//   - r client.ApiDeviceConnectInternalProvisionDeviceRequest
func (_e *MockDeviceConnectInternalAPIAPI_Expecter) DeviceConnectInternalProvisionDeviceExecute(r interface{}) *MockDeviceConnectInternalAPIAPI_DeviceConnectInternalProvisionDeviceExecute_Call {
	return &MockDeviceConnectInternalAPIAPI_DeviceConnectInternalProvisionDeviceExecute_Call{Call: _e.mock.On("DeviceConnectInternalProvisionDeviceExecute", r)}
}

func (_c *MockDeviceConnectInternalAPIAPI_DeviceConnectInternalProvisionDeviceExecute_Call) Run(run func(r client.ApiDeviceConnectInternalProvisionDeviceRequest)) *MockDeviceConnectInternalAPIAPI_DeviceConnectInternalProvisionDeviceExecute_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 client.ApiDeviceConnectInternalProvisionDeviceRequest
		if args[0] != nil {
			arg0 = args[0].(client.ApiDeviceConnectInternalProvisionDeviceRequest)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *MockDeviceConnectInternalAPIAPI_DeviceConnectInternalProvisionDeviceExecute_Call) Return(response *http.Response, err error) *MockDeviceConnectInternalAPIAPI_DeviceConnectInternalProvisionDeviceExecute_Call {
	_c.Call.Return(response, err)
	return _c
}

func (_c *MockDeviceConnectInternalAPIAPI_DeviceConnectInternalProvisionDeviceExecute_Call) RunAndReturn(run func(r client.ApiDeviceConnectInternalProvisionDeviceRequest) (*http.Response, error)) *MockDeviceConnectInternalAPIAPI_DeviceConnectInternalProvisionDeviceExecute_Call {
	_c.Call.Return(run)
	return _c
}

// DeviceConnectInternalSendInventory provides a mock function for the type MockDeviceConnectInternalAPIAPI
func (_mock *MockDeviceConnectInternalAPIAPI) DeviceConnectInternalSendInventory(ctx context.Context, tenantId string, deviceId string) client.ApiDeviceConnectInternalSendInventoryRequest {
	ret := _mock.Called(ctx, tenantId, deviceId)

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

	var r0 client.ApiDeviceConnectInternalSendInventoryRequest
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string) client.ApiDeviceConnectInternalSendInventoryRequest); ok {
		r0 = returnFunc(ctx, tenantId, deviceId)
	} else {
		r0 = ret.Get(0).(client.ApiDeviceConnectInternalSendInventoryRequest)
	}
	return r0
}

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

// DeviceConnectInternalSendInventory is a helper method to define mock.On call
//   - ctx context.Context
//   - tenantId string
//   - deviceId string
func (_e *MockDeviceConnectInternalAPIAPI_Expecter) DeviceConnectInternalSendInventory(ctx interface{}, tenantId interface{}, deviceId interface{}) *MockDeviceConnectInternalAPIAPI_DeviceConnectInternalSendInventory_Call {
	return &MockDeviceConnectInternalAPIAPI_DeviceConnectInternalSendInventory_Call{Call: _e.mock.On("DeviceConnectInternalSendInventory", ctx, tenantId, deviceId)}
}

func (_c *MockDeviceConnectInternalAPIAPI_DeviceConnectInternalSendInventory_Call) Run(run func(ctx context.Context, tenantId string, deviceId string)) *MockDeviceConnectInternalAPIAPI_DeviceConnectInternalSendInventory_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)
		}
		run(
			arg0,
			arg1,
			arg2,
		)
	})
	return _c
}

func (_c *MockDeviceConnectInternalAPIAPI_DeviceConnectInternalSendInventory_Call) Return(apiDeviceConnectInternalSendInventoryRequest client.ApiDeviceConnectInternalSendInventoryRequest) *MockDeviceConnectInternalAPIAPI_DeviceConnectInternalSendInventory_Call {
	_c.Call.Return(apiDeviceConnectInternalSendInventoryRequest)
	return _c
}

func (_c *MockDeviceConnectInternalAPIAPI_DeviceConnectInternalSendInventory_Call) RunAndReturn(run func(ctx context.Context, tenantId string, deviceId string) client.ApiDeviceConnectInternalSendInventoryRequest) *MockDeviceConnectInternalAPIAPI_DeviceConnectInternalSendInventory_Call {
	_c.Call.Return(run)
	return _c
}

// DeviceConnectInternalSendInventoryExecute provides a mock function for the type MockDeviceConnectInternalAPIAPI
func (_mock *MockDeviceConnectInternalAPIAPI) DeviceConnectInternalSendInventoryExecute(r client.ApiDeviceConnectInternalSendInventoryRequest) (*http.Response, error) {
	ret := _mock.Called(r)

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

	var r0 *http.Response
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(client.ApiDeviceConnectInternalSendInventoryRequest) (*http.Response, error)); ok {
		return returnFunc(r)
	}
	if returnFunc, ok := ret.Get(0).(func(client.ApiDeviceConnectInternalSendInventoryRequest) *http.Response); ok {
		r0 = returnFunc(r)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*http.Response)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(client.ApiDeviceConnectInternalSendInventoryRequest) error); ok {
		r1 = returnFunc(r)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// DeviceConnectInternalSendInventoryExecute is a helper method to define mock.On call
//   - r client.ApiDeviceConnectInternalSendInventoryRequest
func (_e *MockDeviceConnectInternalAPIAPI_Expecter) DeviceConnectInternalSendInventoryExecute(r interface{}) *MockDeviceConnectInternalAPIAPI_DeviceConnectInternalSendInventoryExecute_Call {
	return &MockDeviceConnectInternalAPIAPI_DeviceConnectInternalSendInventoryExecute_Call{Call: _e.mock.On("DeviceConnectInternalSendInventoryExecute", r)}
}

func (_c *MockDeviceConnectInternalAPIAPI_DeviceConnectInternalSendInventoryExecute_Call) Run(run func(r client.ApiDeviceConnectInternalSendInventoryRequest)) *MockDeviceConnectInternalAPIAPI_DeviceConnectInternalSendInventoryExecute_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 client.ApiDeviceConnectInternalSendInventoryRequest
		if args[0] != nil {
			arg0 = args[0].(client.ApiDeviceConnectInternalSendInventoryRequest)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *MockDeviceConnectInternalAPIAPI_DeviceConnectInternalSendInventoryExecute_Call) Return(response *http.Response, err error) *MockDeviceConnectInternalAPIAPI_DeviceConnectInternalSendInventoryExecute_Call {
	_c.Call.Return(response, err)
	return _c
}

func (_c *MockDeviceConnectInternalAPIAPI_DeviceConnectInternalSendInventoryExecute_Call) RunAndReturn(run func(r client.ApiDeviceConnectInternalSendInventoryRequest) (*http.Response, error)) *MockDeviceConnectInternalAPIAPI_DeviceConnectInternalSendInventoryExecute_Call {
	_c.Call.Return(run)
	return _c
}

// DeviceConnectInternalShutdown provides a mock function for the type MockDeviceConnectInternalAPIAPI
func (_mock *MockDeviceConnectInternalAPIAPI) DeviceConnectInternalShutdown(ctx context.Context) client.ApiDeviceConnectInternalShutdownRequest {
	ret := _mock.Called(ctx)

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

	var r0 client.ApiDeviceConnectInternalShutdownRequest
	if returnFunc, ok := ret.Get(0).(func(context.Context) client.ApiDeviceConnectInternalShutdownRequest); ok {
		r0 = returnFunc(ctx)
	} else {
		r0 = ret.Get(0).(client.ApiDeviceConnectInternalShutdownRequest)
	}
	return r0
}

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

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

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

func (_c *MockDeviceConnectInternalAPIAPI_DeviceConnectInternalShutdown_Call) Return(apiDeviceConnectInternalShutdownRequest client.ApiDeviceConnectInternalShutdownRequest) *MockDeviceConnectInternalAPIAPI_DeviceConnectInternalShutdown_Call {
	_c.Call.Return(apiDeviceConnectInternalShutdownRequest)
	return _c
}

func (_c *MockDeviceConnectInternalAPIAPI_DeviceConnectInternalShutdown_Call) RunAndReturn(run func(ctx context.Context) client.ApiDeviceConnectInternalShutdownRequest) *MockDeviceConnectInternalAPIAPI_DeviceConnectInternalShutdown_Call {
	_c.Call.Return(run)
	return _c
}

// DeviceConnectInternalShutdownExecute provides a mock function for the type MockDeviceConnectInternalAPIAPI
func (_mock *MockDeviceConnectInternalAPIAPI) DeviceConnectInternalShutdownExecute(r client.ApiDeviceConnectInternalShutdownRequest) (*http.Response, error) {
	ret := _mock.Called(r)

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

	var r0 *http.Response
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(client.ApiDeviceConnectInternalShutdownRequest) (*http.Response, error)); ok {
		return returnFunc(r)
	}
	if returnFunc, ok := ret.Get(0).(func(client.ApiDeviceConnectInternalShutdownRequest) *http.Response); ok {
		r0 = returnFunc(r)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*http.Response)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(client.ApiDeviceConnectInternalShutdownRequest) error); ok {
		r1 = returnFunc(r)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// DeviceConnectInternalShutdownExecute is a helper method to define mock.On call
//   - r client.ApiDeviceConnectInternalShutdownRequest
func (_e *MockDeviceConnectInternalAPIAPI_Expecter) DeviceConnectInternalShutdownExecute(r interface{}) *MockDeviceConnectInternalAPIAPI_DeviceConnectInternalShutdownExecute_Call {
	return &MockDeviceConnectInternalAPIAPI_DeviceConnectInternalShutdownExecute_Call{Call: _e.mock.On("DeviceConnectInternalShutdownExecute", r)}
}

func (_c *MockDeviceConnectInternalAPIAPI_DeviceConnectInternalShutdownExecute_Call) Run(run func(r client.ApiDeviceConnectInternalShutdownRequest)) *MockDeviceConnectInternalAPIAPI_DeviceConnectInternalShutdownExecute_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 client.ApiDeviceConnectInternalShutdownRequest
		if args[0] != nil {
			arg0 = args[0].(client.ApiDeviceConnectInternalShutdownRequest)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *MockDeviceConnectInternalAPIAPI_DeviceConnectInternalShutdownExecute_Call) Return(response *http.Response, err error) *MockDeviceConnectInternalAPIAPI_DeviceConnectInternalShutdownExecute_Call {
	_c.Call.Return(response, err)
	return _c
}

func (_c *MockDeviceConnectInternalAPIAPI_DeviceConnectInternalShutdownExecute_Call) RunAndReturn(run func(r client.ApiDeviceConnectInternalShutdownRequest) (*http.Response, error)) *MockDeviceConnectInternalAPIAPI_DeviceConnectInternalShutdownExecute_Call {
	_c.Call.Return(run)
	return _c
}

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

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

	return mock
}

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

type MockDeviceConnectManagementAPIAPI_Expecter struct {
	mock *mock.Mock
}

func (_m *MockDeviceConnectManagementAPIAPI) EXPECT() *MockDeviceConnectManagementAPIAPI_Expecter {
	return &MockDeviceConnectManagementAPIAPI_Expecter{mock: &_m.Mock}
}

// DeviceConnectManagementCheckUpdate provides a mock function for the type MockDeviceConnectManagementAPIAPI
func (_mock *MockDeviceConnectManagementAPIAPI) DeviceConnectManagementCheckUpdate(ctx context.Context, id string) client.ApiDeviceConnectManagementCheckUpdateRequest {
	ret := _mock.Called(ctx, id)

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

	var r0 client.ApiDeviceConnectManagementCheckUpdateRequest
	if returnFunc, ok := ret.Get(0).(func(context.Context, string) client.ApiDeviceConnectManagementCheckUpdateRequest); ok {
		r0 = returnFunc(ctx, id)
	} else {
		r0 = ret.Get(0).(client.ApiDeviceConnectManagementCheckUpdateRequest)
	}
	return r0
}

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

// DeviceConnectManagementCheckUpdate is a helper method to define mock.On call
//   - ctx context.Context
//   - id string
func (_e *MockDeviceConnectManagementAPIAPI_Expecter) DeviceConnectManagementCheckUpdate(ctx interface{}, id interface{}) *MockDeviceConnectManagementAPIAPI_DeviceConnectManagementCheckUpdate_Call {
	return &MockDeviceConnectManagementAPIAPI_DeviceConnectManagementCheckUpdate_Call{Call: _e.mock.On("DeviceConnectManagementCheckUpdate", ctx, id)}
}

func (_c *MockDeviceConnectManagementAPIAPI_DeviceConnectManagementCheckUpdate_Call) Run(run func(ctx context.Context, id string)) *MockDeviceConnectManagementAPIAPI_DeviceConnectManagementCheckUpdate_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 *MockDeviceConnectManagementAPIAPI_DeviceConnectManagementCheckUpdate_Call) Return(apiDeviceConnectManagementCheckUpdateRequest client.ApiDeviceConnectManagementCheckUpdateRequest) *MockDeviceConnectManagementAPIAPI_DeviceConnectManagementCheckUpdate_Call {
	_c.Call.Return(apiDeviceConnectManagementCheckUpdateRequest)
	return _c
}

func (_c *MockDeviceConnectManagementAPIAPI_DeviceConnectManagementCheckUpdate_Call) RunAndReturn(run func(ctx context.Context, id string) client.ApiDeviceConnectManagementCheckUpdateRequest) *MockDeviceConnectManagementAPIAPI_DeviceConnectManagementCheckUpdate_Call {
	_c.Call.Return(run)
	return _c
}

// DeviceConnectManagementCheckUpdateExecute provides a mock function for the type MockDeviceConnectManagementAPIAPI
func (_mock *MockDeviceConnectManagementAPIAPI) DeviceConnectManagementCheckUpdateExecute(r client.ApiDeviceConnectManagementCheckUpdateRequest) (*http.Response, error) {
	ret := _mock.Called(r)

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

	var r0 *http.Response
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(client.ApiDeviceConnectManagementCheckUpdateRequest) (*http.Response, error)); ok {
		return returnFunc(r)
	}
	if returnFunc, ok := ret.Get(0).(func(client.ApiDeviceConnectManagementCheckUpdateRequest) *http.Response); ok {
		r0 = returnFunc(r)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*http.Response)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(client.ApiDeviceConnectManagementCheckUpdateRequest) error); ok {
		r1 = returnFunc(r)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// DeviceConnectManagementCheckUpdateExecute is a helper method to define mock.On call
//   - r client.ApiDeviceConnectManagementCheckUpdateRequest
func (_e *MockDeviceConnectManagementAPIAPI_Expecter) DeviceConnectManagementCheckUpdateExecute(r interface{}) *MockDeviceConnectManagementAPIAPI_DeviceConnectManagementCheckUpdateExecute_Call {
	return &MockDeviceConnectManagementAPIAPI_DeviceConnectManagementCheckUpdateExecute_Call{Call: _e.mock.On("DeviceConnectManagementCheckUpdateExecute", r)}
}

func (_c *MockDeviceConnectManagementAPIAPI_DeviceConnectManagementCheckUpdateExecute_Call) Run(run func(r client.ApiDeviceConnectManagementCheckUpdateRequest)) *MockDeviceConnectManagementAPIAPI_DeviceConnectManagementCheckUpdateExecute_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 client.ApiDeviceConnectManagementCheckUpdateRequest
		if args[0] != nil {
			arg0 = args[0].(client.ApiDeviceConnectManagementCheckUpdateRequest)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *MockDeviceConnectManagementAPIAPI_DeviceConnectManagementCheckUpdateExecute_Call) Return(response *http.Response, err error) *MockDeviceConnectManagementAPIAPI_DeviceConnectManagementCheckUpdateExecute_Call {
	_c.Call.Return(response, err)
	return _c
}

func (_c *MockDeviceConnectManagementAPIAPI_DeviceConnectManagementCheckUpdateExecute_Call) RunAndReturn(run func(r client.ApiDeviceConnectManagementCheckUpdateRequest) (*http.Response, error)) *MockDeviceConnectManagementAPIAPI_DeviceConnectManagementCheckUpdateExecute_Call {
	_c.Call.Return(run)
	return _c
}

// DeviceConnectManagementConnect provides a mock function for the type MockDeviceConnectManagementAPIAPI
func (_mock *MockDeviceConnectManagementAPIAPI) DeviceConnectManagementConnect(ctx context.Context, id string) client.ApiDeviceConnectManagementConnectRequest {
	ret := _mock.Called(ctx, id)

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

	var r0 client.ApiDeviceConnectManagementConnectRequest
	if returnFunc, ok := ret.Get(0).(func(context.Context, string) client.ApiDeviceConnectManagementConnectRequest); ok {
		r0 = returnFunc(ctx, id)
	} else {
		r0 = ret.Get(0).(client.ApiDeviceConnectManagementConnectRequest)
	}
	return r0
}

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

// DeviceConnectManagementConnect is a helper method to define mock.On call
//   - ctx context.Context
//   - id string
func (_e *MockDeviceConnectManagementAPIAPI_Expecter) DeviceConnectManagementConnect(ctx interface{}, id interface{}) *MockDeviceConnectManagementAPIAPI_DeviceConnectManagementConnect_Call {
	return &MockDeviceConnectManagementAPIAPI_DeviceConnectManagementConnect_Call{Call: _e.mock.On("DeviceConnectManagementConnect", ctx, id)}
}

func (_c *MockDeviceConnectManagementAPIAPI_DeviceConnectManagementConnect_Call) Run(run func(ctx context.Context, id string)) *MockDeviceConnectManagementAPIAPI_DeviceConnectManagementConnect_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 *MockDeviceConnectManagementAPIAPI_DeviceConnectManagementConnect_Call) Return(apiDeviceConnectManagementConnectRequest client.ApiDeviceConnectManagementConnectRequest) *MockDeviceConnectManagementAPIAPI_DeviceConnectManagementConnect_Call {
	_c.Call.Return(apiDeviceConnectManagementConnectRequest)
	return _c
}

func (_c *MockDeviceConnectManagementAPIAPI_DeviceConnectManagementConnect_Call) RunAndReturn(run func(ctx context.Context, id string) client.ApiDeviceConnectManagementConnectRequest) *MockDeviceConnectManagementAPIAPI_DeviceConnectManagementConnect_Call {
	_c.Call.Return(run)
	return _c
}

// DeviceConnectManagementConnectExecute provides a mock function for the type MockDeviceConnectManagementAPIAPI
func (_mock *MockDeviceConnectManagementAPIAPI) DeviceConnectManagementConnectExecute(r client.ApiDeviceConnectManagementConnectRequest) (*http.Response, error) {
	ret := _mock.Called(r)

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

	var r0 *http.Response
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(client.ApiDeviceConnectManagementConnectRequest) (*http.Response, error)); ok {
		return returnFunc(r)
	}
	if returnFunc, ok := ret.Get(0).(func(client.ApiDeviceConnectManagementConnectRequest) *http.Response); ok {
		r0 = returnFunc(r)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*http.Response)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(client.ApiDeviceConnectManagementConnectRequest) error); ok {
		r1 = returnFunc(r)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// DeviceConnectManagementConnectExecute is a helper method to define mock.On call
//   - r client.ApiDeviceConnectManagementConnectRequest
func (_e *MockDeviceConnectManagementAPIAPI_Expecter) DeviceConnectManagementConnectExecute(r interface{}) *MockDeviceConnectManagementAPIAPI_DeviceConnectManagementConnectExecute_Call {
	return &MockDeviceConnectManagementAPIAPI_DeviceConnectManagementConnectExecute_Call{Call: _e.mock.On("DeviceConnectManagementConnectExecute", r)}
}

func (_c *MockDeviceConnectManagementAPIAPI_DeviceConnectManagementConnectExecute_Call) Run(run func(r client.ApiDeviceConnectManagementConnectRequest)) *MockDeviceConnectManagementAPIAPI_DeviceConnectManagementConnectExecute_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 client.ApiDeviceConnectManagementConnectRequest
		if args[0] != nil {
			arg0 = args[0].(client.ApiDeviceConnectManagementConnectRequest)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *MockDeviceConnectManagementAPIAPI_DeviceConnectManagementConnectExecute_Call) Return(response *http.Response, err error) *MockDeviceConnectManagementAPIAPI_DeviceConnectManagementConnectExecute_Call {
	_c.Call.Return(response, err)
	return _c
}

func (_c *MockDeviceConnectManagementAPIAPI_DeviceConnectManagementConnectExecute_Call) RunAndReturn(run func(r client.ApiDeviceConnectManagementConnectRequest) (*http.Response, error)) *MockDeviceConnectManagementAPIAPI_DeviceConnectManagementConnectExecute_Call {
	_c.Call.Return(run)
	return _c
}

// DeviceConnectManagementDownload provides a mock function for the type MockDeviceConnectManagementAPIAPI
func (_mock *MockDeviceConnectManagementAPIAPI) DeviceConnectManagementDownload(ctx context.Context, id string) client.ApiDeviceConnectManagementDownloadRequest {
	ret := _mock.Called(ctx, id)

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

	var r0 client.ApiDeviceConnectManagementDownloadRequest
	if returnFunc, ok := ret.Get(0).(func(context.Context, string) client.ApiDeviceConnectManagementDownloadRequest); ok {
		r0 = returnFunc(ctx, id)
	} else {
		r0 = ret.Get(0).(client.ApiDeviceConnectManagementDownloadRequest)
	}
	return r0
}

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

// DeviceConnectManagementDownload is a helper method to define mock.On call
//   - ctx context.Context
//   - id string
func (_e *MockDeviceConnectManagementAPIAPI_Expecter) DeviceConnectManagementDownload(ctx interface{}, id interface{}) *MockDeviceConnectManagementAPIAPI_DeviceConnectManagementDownload_Call {
	return &MockDeviceConnectManagementAPIAPI_DeviceConnectManagementDownload_Call{Call: _e.mock.On("DeviceConnectManagementDownload", ctx, id)}
}

func (_c *MockDeviceConnectManagementAPIAPI_DeviceConnectManagementDownload_Call) Run(run func(ctx context.Context, id string)) *MockDeviceConnectManagementAPIAPI_DeviceConnectManagementDownload_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 *MockDeviceConnectManagementAPIAPI_DeviceConnectManagementDownload_Call) Return(apiDeviceConnectManagementDownloadRequest client.ApiDeviceConnectManagementDownloadRequest) *MockDeviceConnectManagementAPIAPI_DeviceConnectManagementDownload_Call {
	_c.Call.Return(apiDeviceConnectManagementDownloadRequest)
	return _c
}

func (_c *MockDeviceConnectManagementAPIAPI_DeviceConnectManagementDownload_Call) RunAndReturn(run func(ctx context.Context, id string) client.ApiDeviceConnectManagementDownloadRequest) *MockDeviceConnectManagementAPIAPI_DeviceConnectManagementDownload_Call {
	_c.Call.Return(run)
	return _c
}

// DeviceConnectManagementDownloadExecute provides a mock function for the type MockDeviceConnectManagementAPIAPI
func (_mock *MockDeviceConnectManagementAPIAPI) DeviceConnectManagementDownloadExecute(r client.ApiDeviceConnectManagementDownloadRequest) (*os.File, *http.Response, error) {
	ret := _mock.Called(r)

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

	var r0 *os.File
	var r1 *http.Response
	var r2 error
	if returnFunc, ok := ret.Get(0).(func(client.ApiDeviceConnectManagementDownloadRequest) (*os.File, *http.Response, error)); ok {
		return returnFunc(r)
	}
	if returnFunc, ok := ret.Get(0).(func(client.ApiDeviceConnectManagementDownloadRequest) *os.File); ok {
		r0 = returnFunc(r)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*os.File)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(client.ApiDeviceConnectManagementDownloadRequest) *http.Response); ok {
		r1 = returnFunc(r)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*http.Response)
		}
	}
	if returnFunc, ok := ret.Get(2).(func(client.ApiDeviceConnectManagementDownloadRequest) error); ok {
		r2 = returnFunc(r)
	} else {
		r2 = ret.Error(2)
	}
	return r0, r1, r2
}

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

// DeviceConnectManagementDownloadExecute is a helper method to define mock.On call
//   - r client.ApiDeviceConnectManagementDownloadRequest
func (_e *MockDeviceConnectManagementAPIAPI_Expecter) DeviceConnectManagementDownloadExecute(r interface{}) *MockDeviceConnectManagementAPIAPI_DeviceConnectManagementDownloadExecute_Call {
	return &MockDeviceConnectManagementAPIAPI_DeviceConnectManagementDownloadExecute_Call{Call: _e.mock.On("DeviceConnectManagementDownloadExecute", r)}
}

func (_c *MockDeviceConnectManagementAPIAPI_DeviceConnectManagementDownloadExecute_Call) Run(run func(r client.ApiDeviceConnectManagementDownloadRequest)) *MockDeviceConnectManagementAPIAPI_DeviceConnectManagementDownloadExecute_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 client.ApiDeviceConnectManagementDownloadRequest
		if args[0] != nil {
			arg0 = args[0].(client.ApiDeviceConnectManagementDownloadRequest)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *MockDeviceConnectManagementAPIAPI_DeviceConnectManagementDownloadExecute_Call) Return(file *os.File, response *http.Response, err error) *MockDeviceConnectManagementAPIAPI_DeviceConnectManagementDownloadExecute_Call {
	_c.Call.Return(file, response, err)
	return _c
}

func (_c *MockDeviceConnectManagementAPIAPI_DeviceConnectManagementDownloadExecute_Call) RunAndReturn(run func(r client.ApiDeviceConnectManagementDownloadRequest) (*os.File, *http.Response, error)) *MockDeviceConnectManagementAPIAPI_DeviceConnectManagementDownloadExecute_Call {
	_c.Call.Return(run)
	return _c
}

// DeviceConnectManagementGetDevice provides a mock function for the type MockDeviceConnectManagementAPIAPI
func (_mock *MockDeviceConnectManagementAPIAPI) DeviceConnectManagementGetDevice(ctx context.Context, id string) client.ApiDeviceConnectManagementGetDeviceRequest {
	ret := _mock.Called(ctx, id)

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

	var r0 client.ApiDeviceConnectManagementGetDeviceRequest
	if returnFunc, ok := ret.Get(0).(func(context.Context, string) client.ApiDeviceConnectManagementGetDeviceRequest); ok {
		r0 = returnFunc(ctx, id)
	} else {
		r0 = ret.Get(0).(client.ApiDeviceConnectManagementGetDeviceRequest)
	}
	return r0
}

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

// DeviceConnectManagementGetDevice is a helper method to define mock.On call
//   - ctx context.Context
//   - id string
func (_e *MockDeviceConnectManagementAPIAPI_Expecter) DeviceConnectManagementGetDevice(ctx interface{}, id interface{}) *MockDeviceConnectManagementAPIAPI_DeviceConnectManagementGetDevice_Call {
	return &MockDeviceConnectManagementAPIAPI_DeviceConnectManagementGetDevice_Call{Call: _e.mock.On("DeviceConnectManagementGetDevice", ctx, id)}
}

func (_c *MockDeviceConnectManagementAPIAPI_DeviceConnectManagementGetDevice_Call) Run(run func(ctx context.Context, id string)) *MockDeviceConnectManagementAPIAPI_DeviceConnectManagementGetDevice_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 *MockDeviceConnectManagementAPIAPI_DeviceConnectManagementGetDevice_Call) Return(apiDeviceConnectManagementGetDeviceRequest client.ApiDeviceConnectManagementGetDeviceRequest) *MockDeviceConnectManagementAPIAPI_DeviceConnectManagementGetDevice_Call {
	_c.Call.Return(apiDeviceConnectManagementGetDeviceRequest)
	return _c
}

func (_c *MockDeviceConnectManagementAPIAPI_DeviceConnectManagementGetDevice_Call) RunAndReturn(run func(ctx context.Context, id string) client.ApiDeviceConnectManagementGetDeviceRequest) *MockDeviceConnectManagementAPIAPI_DeviceConnectManagementGetDevice_Call {
	_c.Call.Return(run)
	return _c
}

// DeviceConnectManagementGetDeviceExecute provides a mock function for the type MockDeviceConnectManagementAPIAPI
func (_mock *MockDeviceConnectManagementAPIAPI) DeviceConnectManagementGetDeviceExecute(r client.ApiDeviceConnectManagementGetDeviceRequest) (*client.ConnectionState, *http.Response, error) {
	ret := _mock.Called(r)

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

	var r0 *client.ConnectionState
	var r1 *http.Response
	var r2 error
	if returnFunc, ok := ret.Get(0).(func(client.ApiDeviceConnectManagementGetDeviceRequest) (*client.ConnectionState, *http.Response, error)); ok {
		return returnFunc(r)
	}
	if returnFunc, ok := ret.Get(0).(func(client.ApiDeviceConnectManagementGetDeviceRequest) *client.ConnectionState); ok {
		r0 = returnFunc(r)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*client.ConnectionState)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(client.ApiDeviceConnectManagementGetDeviceRequest) *http.Response); ok {
		r1 = returnFunc(r)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*http.Response)
		}
	}
	if returnFunc, ok := ret.Get(2).(func(client.ApiDeviceConnectManagementGetDeviceRequest) error); ok {
		r2 = returnFunc(r)
	} else {
		r2 = ret.Error(2)
	}
	return r0, r1, r2
}

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

// DeviceConnectManagementGetDeviceExecute is a helper method to define mock.On call
//   - r client.ApiDeviceConnectManagementGetDeviceRequest
func (_e *MockDeviceConnectManagementAPIAPI_Expecter) DeviceConnectManagementGetDeviceExecute(r interface{}) *MockDeviceConnectManagementAPIAPI_DeviceConnectManagementGetDeviceExecute_Call {
	return &MockDeviceConnectManagementAPIAPI_DeviceConnectManagementGetDeviceExecute_Call{Call: _e.mock.On("DeviceConnectManagementGetDeviceExecute", r)}
}

func (_c *MockDeviceConnectManagementAPIAPI_DeviceConnectManagementGetDeviceExecute_Call) Run(run func(r client.ApiDeviceConnectManagementGetDeviceRequest)) *MockDeviceConnectManagementAPIAPI_DeviceConnectManagementGetDeviceExecute_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 client.ApiDeviceConnectManagementGetDeviceRequest
		if args[0] != nil {
			arg0 = args[0].(client.ApiDeviceConnectManagementGetDeviceRequest)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *MockDeviceConnectManagementAPIAPI_DeviceConnectManagementGetDeviceExecute_Call) Return(connectionState *client.ConnectionState, response *http.Response, err error) *MockDeviceConnectManagementAPIAPI_DeviceConnectManagementGetDeviceExecute_Call {
	_c.Call.Return(connectionState, response, err)
	return _c
}

func (_c *MockDeviceConnectManagementAPIAPI_DeviceConnectManagementGetDeviceExecute_Call) RunAndReturn(run func(r client.ApiDeviceConnectManagementGetDeviceRequest) (*client.ConnectionState, *http.Response, error)) *MockDeviceConnectManagementAPIAPI_DeviceConnectManagementGetDeviceExecute_Call {
	_c.Call.Return(run)
	return _c
}

// DeviceConnectManagementPlayback provides a mock function for the type MockDeviceConnectManagementAPIAPI
func (_mock *MockDeviceConnectManagementAPIAPI) DeviceConnectManagementPlayback(ctx context.Context, sessionId string) client.ApiDeviceConnectManagementPlaybackRequest {
	ret := _mock.Called(ctx, sessionId)

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

	var r0 client.ApiDeviceConnectManagementPlaybackRequest
	if returnFunc, ok := ret.Get(0).(func(context.Context, string) client.ApiDeviceConnectManagementPlaybackRequest); ok {
		r0 = returnFunc(ctx, sessionId)
	} else {
		r0 = ret.Get(0).(client.ApiDeviceConnectManagementPlaybackRequest)
	}
	return r0
}

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

// DeviceConnectManagementPlayback is a helper method to define mock.On call
//   - ctx context.Context
//   - sessionId string
func (_e *MockDeviceConnectManagementAPIAPI_Expecter) DeviceConnectManagementPlayback(ctx interface{}, sessionId interface{}) *MockDeviceConnectManagementAPIAPI_DeviceConnectManagementPlayback_Call {
	return &MockDeviceConnectManagementAPIAPI_DeviceConnectManagementPlayback_Call{Call: _e.mock.On("DeviceConnectManagementPlayback", ctx, sessionId)}
}

func (_c *MockDeviceConnectManagementAPIAPI_DeviceConnectManagementPlayback_Call) Run(run func(ctx context.Context, sessionId string)) *MockDeviceConnectManagementAPIAPI_DeviceConnectManagementPlayback_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 *MockDeviceConnectManagementAPIAPI_DeviceConnectManagementPlayback_Call) Return(apiDeviceConnectManagementPlaybackRequest client.ApiDeviceConnectManagementPlaybackRequest) *MockDeviceConnectManagementAPIAPI_DeviceConnectManagementPlayback_Call {
	_c.Call.Return(apiDeviceConnectManagementPlaybackRequest)
	return _c
}

func (_c *MockDeviceConnectManagementAPIAPI_DeviceConnectManagementPlayback_Call) RunAndReturn(run func(ctx context.Context, sessionId string) client.ApiDeviceConnectManagementPlaybackRequest) *MockDeviceConnectManagementAPIAPI_DeviceConnectManagementPlayback_Call {
	_c.Call.Return(run)
	return _c
}

// DeviceConnectManagementPlaybackExecute provides a mock function for the type MockDeviceConnectManagementAPIAPI
func (_mock *MockDeviceConnectManagementAPIAPI) DeviceConnectManagementPlaybackExecute(r client.ApiDeviceConnectManagementPlaybackRequest) (*http.Response, error) {
	ret := _mock.Called(r)

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

	var r0 *http.Response
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(client.ApiDeviceConnectManagementPlaybackRequest) (*http.Response, error)); ok {
		return returnFunc(r)
	}
	if returnFunc, ok := ret.Get(0).(func(client.ApiDeviceConnectManagementPlaybackRequest) *http.Response); ok {
		r0 = returnFunc(r)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*http.Response)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(client.ApiDeviceConnectManagementPlaybackRequest) error); ok {
		r1 = returnFunc(r)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// DeviceConnectManagementPlaybackExecute is a helper method to define mock.On call
//   - r client.ApiDeviceConnectManagementPlaybackRequest
func (_e *MockDeviceConnectManagementAPIAPI_Expecter) DeviceConnectManagementPlaybackExecute(r interface{}) *MockDeviceConnectManagementAPIAPI_DeviceConnectManagementPlaybackExecute_Call {
	return &MockDeviceConnectManagementAPIAPI_DeviceConnectManagementPlaybackExecute_Call{Call: _e.mock.On("DeviceConnectManagementPlaybackExecute", r)}
}

func (_c *MockDeviceConnectManagementAPIAPI_DeviceConnectManagementPlaybackExecute_Call) Run(run func(r client.ApiDeviceConnectManagementPlaybackRequest)) *MockDeviceConnectManagementAPIAPI_DeviceConnectManagementPlaybackExecute_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 client.ApiDeviceConnectManagementPlaybackRequest
		if args[0] != nil {
			arg0 = args[0].(client.ApiDeviceConnectManagementPlaybackRequest)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *MockDeviceConnectManagementAPIAPI_DeviceConnectManagementPlaybackExecute_Call) Return(response *http.Response, err error) *MockDeviceConnectManagementAPIAPI_DeviceConnectManagementPlaybackExecute_Call {
	_c.Call.Return(response, err)
	return _c
}

func (_c *MockDeviceConnectManagementAPIAPI_DeviceConnectManagementPlaybackExecute_Call) RunAndReturn(run func(r client.ApiDeviceConnectManagementPlaybackRequest) (*http.Response, error)) *MockDeviceConnectManagementAPIAPI_DeviceConnectManagementPlaybackExecute_Call {
	_c.Call.Return(run)
	return _c
}

// DeviceConnectManagementSendInventory provides a mock function for the type MockDeviceConnectManagementAPIAPI
func (_mock *MockDeviceConnectManagementAPIAPI) DeviceConnectManagementSendInventory(ctx context.Context, id string) client.ApiDeviceConnectManagementSendInventoryRequest {
	ret := _mock.Called(ctx, id)

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

	var r0 client.ApiDeviceConnectManagementSendInventoryRequest
	if returnFunc, ok := ret.Get(0).(func(context.Context, string) client.ApiDeviceConnectManagementSendInventoryRequest); ok {
		r0 = returnFunc(ctx, id)
	} else {
		r0 = ret.Get(0).(client.ApiDeviceConnectManagementSendInventoryRequest)
	}
	return r0
}

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

// DeviceConnectManagementSendInventory is a helper method to define mock.On call
//   - ctx context.Context
//   - id string
func (_e *MockDeviceConnectManagementAPIAPI_Expecter) DeviceConnectManagementSendInventory(ctx interface{}, id interface{}) *MockDeviceConnectManagementAPIAPI_DeviceConnectManagementSendInventory_Call {
	return &MockDeviceConnectManagementAPIAPI_DeviceConnectManagementSendInventory_Call{Call: _e.mock.On("DeviceConnectManagementSendInventory", ctx, id)}
}

func (_c *MockDeviceConnectManagementAPIAPI_DeviceConnectManagementSendInventory_Call) Run(run func(ctx context.Context, id string)) *MockDeviceConnectManagementAPIAPI_DeviceConnectManagementSendInventory_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 *MockDeviceConnectManagementAPIAPI_DeviceConnectManagementSendInventory_Call) Return(apiDeviceConnectManagementSendInventoryRequest client.ApiDeviceConnectManagementSendInventoryRequest) *MockDeviceConnectManagementAPIAPI_DeviceConnectManagementSendInventory_Call {
	_c.Call.Return(apiDeviceConnectManagementSendInventoryRequest)
	return _c
}

func (_c *MockDeviceConnectManagementAPIAPI_DeviceConnectManagementSendInventory_Call) RunAndReturn(run func(ctx context.Context, id string) client.ApiDeviceConnectManagementSendInventoryRequest) *MockDeviceConnectManagementAPIAPI_DeviceConnectManagementSendInventory_Call {
	_c.Call.Return(run)
	return _c
}

// DeviceConnectManagementSendInventoryExecute provides a mock function for the type MockDeviceConnectManagementAPIAPI
func (_mock *MockDeviceConnectManagementAPIAPI) DeviceConnectManagementSendInventoryExecute(r client.ApiDeviceConnectManagementSendInventoryRequest) (*http.Response, error) {
	ret := _mock.Called(r)

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

	var r0 *http.Response
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(client.ApiDeviceConnectManagementSendInventoryRequest) (*http.Response, error)); ok {
		return returnFunc(r)
	}
	if returnFunc, ok := ret.Get(0).(func(client.ApiDeviceConnectManagementSendInventoryRequest) *http.Response); ok {
		r0 = returnFunc(r)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*http.Response)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(client.ApiDeviceConnectManagementSendInventoryRequest) error); ok {
		r1 = returnFunc(r)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// DeviceConnectManagementSendInventoryExecute is a helper method to define mock.On call
//   - r client.ApiDeviceConnectManagementSendInventoryRequest
func (_e *MockDeviceConnectManagementAPIAPI_Expecter) DeviceConnectManagementSendInventoryExecute(r interface{}) *MockDeviceConnectManagementAPIAPI_DeviceConnectManagementSendInventoryExecute_Call {
	return &MockDeviceConnectManagementAPIAPI_DeviceConnectManagementSendInventoryExecute_Call{Call: _e.mock.On("DeviceConnectManagementSendInventoryExecute", r)}
}

func (_c *MockDeviceConnectManagementAPIAPI_DeviceConnectManagementSendInventoryExecute_Call) Run(run func(r client.ApiDeviceConnectManagementSendInventoryRequest)) *MockDeviceConnectManagementAPIAPI_DeviceConnectManagementSendInventoryExecute_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 client.ApiDeviceConnectManagementSendInventoryRequest
		if args[0] != nil {
			arg0 = args[0].(client.ApiDeviceConnectManagementSendInventoryRequest)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *MockDeviceConnectManagementAPIAPI_DeviceConnectManagementSendInventoryExecute_Call) Return(response *http.Response, err error) *MockDeviceConnectManagementAPIAPI_DeviceConnectManagementSendInventoryExecute_Call {
	_c.Call.Return(response, err)
	return _c
}

func (_c *MockDeviceConnectManagementAPIAPI_DeviceConnectManagementSendInventoryExecute_Call) RunAndReturn(run func(r client.ApiDeviceConnectManagementSendInventoryRequest) (*http.Response, error)) *MockDeviceConnectManagementAPIAPI_DeviceConnectManagementSendInventoryExecute_Call {
	_c.Call.Return(run)
	return _c
}

// DeviceConnectManagementUpload provides a mock function for the type MockDeviceConnectManagementAPIAPI
func (_mock *MockDeviceConnectManagementAPIAPI) DeviceConnectManagementUpload(ctx context.Context, id string) client.ApiDeviceConnectManagementUploadRequest {
	ret := _mock.Called(ctx, id)

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

	var r0 client.ApiDeviceConnectManagementUploadRequest
	if returnFunc, ok := ret.Get(0).(func(context.Context, string) client.ApiDeviceConnectManagementUploadRequest); ok {
		r0 = returnFunc(ctx, id)
	} else {
		r0 = ret.Get(0).(client.ApiDeviceConnectManagementUploadRequest)
	}
	return r0
}

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

// DeviceConnectManagementUpload is a helper method to define mock.On call
//   - ctx context.Context
//   - id string
func (_e *MockDeviceConnectManagementAPIAPI_Expecter) DeviceConnectManagementUpload(ctx interface{}, id interface{}) *MockDeviceConnectManagementAPIAPI_DeviceConnectManagementUpload_Call {
	return &MockDeviceConnectManagementAPIAPI_DeviceConnectManagementUpload_Call{Call: _e.mock.On("DeviceConnectManagementUpload", ctx, id)}
}

func (_c *MockDeviceConnectManagementAPIAPI_DeviceConnectManagementUpload_Call) Run(run func(ctx context.Context, id string)) *MockDeviceConnectManagementAPIAPI_DeviceConnectManagementUpload_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 *MockDeviceConnectManagementAPIAPI_DeviceConnectManagementUpload_Call) Return(apiDeviceConnectManagementUploadRequest client.ApiDeviceConnectManagementUploadRequest) *MockDeviceConnectManagementAPIAPI_DeviceConnectManagementUpload_Call {
	_c.Call.Return(apiDeviceConnectManagementUploadRequest)
	return _c
}

func (_c *MockDeviceConnectManagementAPIAPI_DeviceConnectManagementUpload_Call) RunAndReturn(run func(ctx context.Context, id string) client.ApiDeviceConnectManagementUploadRequest) *MockDeviceConnectManagementAPIAPI_DeviceConnectManagementUpload_Call {
	_c.Call.Return(run)
	return _c
}

// DeviceConnectManagementUploadExecute provides a mock function for the type MockDeviceConnectManagementAPIAPI
func (_mock *MockDeviceConnectManagementAPIAPI) DeviceConnectManagementUploadExecute(r client.ApiDeviceConnectManagementUploadRequest) (*http.Response, error) {
	ret := _mock.Called(r)

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

	var r0 *http.Response
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(client.ApiDeviceConnectManagementUploadRequest) (*http.Response, error)); ok {
		return returnFunc(r)
	}
	if returnFunc, ok := ret.Get(0).(func(client.ApiDeviceConnectManagementUploadRequest) *http.Response); ok {
		r0 = returnFunc(r)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*http.Response)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(client.ApiDeviceConnectManagementUploadRequest) error); ok {
		r1 = returnFunc(r)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// DeviceConnectManagementUploadExecute is a helper method to define mock.On call
//   - r client.ApiDeviceConnectManagementUploadRequest
func (_e *MockDeviceConnectManagementAPIAPI_Expecter) DeviceConnectManagementUploadExecute(r interface{}) *MockDeviceConnectManagementAPIAPI_DeviceConnectManagementUploadExecute_Call {
	return &MockDeviceConnectManagementAPIAPI_DeviceConnectManagementUploadExecute_Call{Call: _e.mock.On("DeviceConnectManagementUploadExecute", r)}
}

func (_c *MockDeviceConnectManagementAPIAPI_DeviceConnectManagementUploadExecute_Call) Run(run func(r client.ApiDeviceConnectManagementUploadRequest)) *MockDeviceConnectManagementAPIAPI_DeviceConnectManagementUploadExecute_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 client.ApiDeviceConnectManagementUploadRequest
		if args[0] != nil {
			arg0 = args[0].(client.ApiDeviceConnectManagementUploadRequest)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *MockDeviceConnectManagementAPIAPI_DeviceConnectManagementUploadExecute_Call) Return(response *http.Response, err error) *MockDeviceConnectManagementAPIAPI_DeviceConnectManagementUploadExecute_Call {
	_c.Call.Return(response, err)
	return _c
}

func (_c *MockDeviceConnectManagementAPIAPI_DeviceConnectManagementUploadExecute_Call) RunAndReturn(run func(r client.ApiDeviceConnectManagementUploadRequest) (*http.Response, error)) *MockDeviceConnectManagementAPIAPI_DeviceConnectManagementUploadExecute_Call {
	_c.Call.Return(run)
	return _c
}

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

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

	return mock
}

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

type MockDeviceInventoryDeviceAPIAPI_Expecter struct {
	mock *mock.Mock
}

func (_m *MockDeviceInventoryDeviceAPIAPI) EXPECT() *MockDeviceInventoryDeviceAPIAPI_Expecter {
	return &MockDeviceInventoryDeviceAPIAPI_Expecter{mock: &_m.Mock}
}

// AssignAttributes provides a mock function for the type MockDeviceInventoryDeviceAPIAPI
func (_mock *MockDeviceInventoryDeviceAPIAPI) AssignAttributes(ctx context.Context) client.ApiAssignAttributesRequest {
	ret := _mock.Called(ctx)

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

	var r0 client.ApiAssignAttributesRequest
	if returnFunc, ok := ret.Get(0).(func(context.Context) client.ApiAssignAttributesRequest); ok {
		r0 = returnFunc(ctx)
	} else {
		r0 = ret.Get(0).(client.ApiAssignAttributesRequest)
	}
	return r0
}

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

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

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

func (_c *MockDeviceInventoryDeviceAPIAPI_AssignAttributes_Call) Return(apiAssignAttributesRequest client.ApiAssignAttributesRequest) *MockDeviceInventoryDeviceAPIAPI_AssignAttributes_Call {
	_c.Call.Return(apiAssignAttributesRequest)
	return _c
}

func (_c *MockDeviceInventoryDeviceAPIAPI_AssignAttributes_Call) RunAndReturn(run func(ctx context.Context) client.ApiAssignAttributesRequest) *MockDeviceInventoryDeviceAPIAPI_AssignAttributes_Call {
	_c.Call.Return(run)
	return _c
}

// AssignAttributesExecute provides a mock function for the type MockDeviceInventoryDeviceAPIAPI
func (_mock *MockDeviceInventoryDeviceAPIAPI) AssignAttributesExecute(r client.ApiAssignAttributesRequest) (*http.Response, error) {
	ret := _mock.Called(r)

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

	var r0 *http.Response
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(client.ApiAssignAttributesRequest) (*http.Response, error)); ok {
		return returnFunc(r)
	}
	if returnFunc, ok := ret.Get(0).(func(client.ApiAssignAttributesRequest) *http.Response); ok {
		r0 = returnFunc(r)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*http.Response)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(client.ApiAssignAttributesRequest) error); ok {
		r1 = returnFunc(r)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// AssignAttributesExecute is a helper method to define mock.On call
//   - r client.ApiAssignAttributesRequest
func (_e *MockDeviceInventoryDeviceAPIAPI_Expecter) AssignAttributesExecute(r interface{}) *MockDeviceInventoryDeviceAPIAPI_AssignAttributesExecute_Call {
	return &MockDeviceInventoryDeviceAPIAPI_AssignAttributesExecute_Call{Call: _e.mock.On("AssignAttributesExecute", r)}
}

func (_c *MockDeviceInventoryDeviceAPIAPI_AssignAttributesExecute_Call) Run(run func(r client.ApiAssignAttributesRequest)) *MockDeviceInventoryDeviceAPIAPI_AssignAttributesExecute_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 client.ApiAssignAttributesRequest
		if args[0] != nil {
			arg0 = args[0].(client.ApiAssignAttributesRequest)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *MockDeviceInventoryDeviceAPIAPI_AssignAttributesExecute_Call) Return(response *http.Response, err error) *MockDeviceInventoryDeviceAPIAPI_AssignAttributesExecute_Call {
	_c.Call.Return(response, err)
	return _c
}

func (_c *MockDeviceInventoryDeviceAPIAPI_AssignAttributesExecute_Call) RunAndReturn(run func(r client.ApiAssignAttributesRequest) (*http.Response, error)) *MockDeviceInventoryDeviceAPIAPI_AssignAttributesExecute_Call {
	_c.Call.Return(run)
	return _c
}

// ReplaceAttributes provides a mock function for the type MockDeviceInventoryDeviceAPIAPI
func (_mock *MockDeviceInventoryDeviceAPIAPI) ReplaceAttributes(ctx context.Context) client.ApiReplaceAttributesRequest {
	ret := _mock.Called(ctx)

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

	var r0 client.ApiReplaceAttributesRequest
	if returnFunc, ok := ret.Get(0).(func(context.Context) client.ApiReplaceAttributesRequest); ok {
		r0 = returnFunc(ctx)
	} else {
		r0 = ret.Get(0).(client.ApiReplaceAttributesRequest)
	}
	return r0
}

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

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

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

func (_c *MockDeviceInventoryDeviceAPIAPI_ReplaceAttributes_Call) Return(apiReplaceAttributesRequest client.ApiReplaceAttributesRequest) *MockDeviceInventoryDeviceAPIAPI_ReplaceAttributes_Call {
	_c.Call.Return(apiReplaceAttributesRequest)
	return _c
}

func (_c *MockDeviceInventoryDeviceAPIAPI_ReplaceAttributes_Call) RunAndReturn(run func(ctx context.Context) client.ApiReplaceAttributesRequest) *MockDeviceInventoryDeviceAPIAPI_ReplaceAttributes_Call {
	_c.Call.Return(run)
	return _c
}

// ReplaceAttributesExecute provides a mock function for the type MockDeviceInventoryDeviceAPIAPI
func (_mock *MockDeviceInventoryDeviceAPIAPI) ReplaceAttributesExecute(r client.ApiReplaceAttributesRequest) (*http.Response, error) {
	ret := _mock.Called(r)

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

	var r0 *http.Response
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(client.ApiReplaceAttributesRequest) (*http.Response, error)); ok {
		return returnFunc(r)
	}
	if returnFunc, ok := ret.Get(0).(func(client.ApiReplaceAttributesRequest) *http.Response); ok {
		r0 = returnFunc(r)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*http.Response)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(client.ApiReplaceAttributesRequest) error); ok {
		r1 = returnFunc(r)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// ReplaceAttributesExecute is a helper method to define mock.On call
//   - r client.ApiReplaceAttributesRequest
func (_e *MockDeviceInventoryDeviceAPIAPI_Expecter) ReplaceAttributesExecute(r interface{}) *MockDeviceInventoryDeviceAPIAPI_ReplaceAttributesExecute_Call {
	return &MockDeviceInventoryDeviceAPIAPI_ReplaceAttributesExecute_Call{Call: _e.mock.On("ReplaceAttributesExecute", r)}
}

func (_c *MockDeviceInventoryDeviceAPIAPI_ReplaceAttributesExecute_Call) Run(run func(r client.ApiReplaceAttributesRequest)) *MockDeviceInventoryDeviceAPIAPI_ReplaceAttributesExecute_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 client.ApiReplaceAttributesRequest
		if args[0] != nil {
			arg0 = args[0].(client.ApiReplaceAttributesRequest)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *MockDeviceInventoryDeviceAPIAPI_ReplaceAttributesExecute_Call) Return(response *http.Response, err error) *MockDeviceInventoryDeviceAPIAPI_ReplaceAttributesExecute_Call {
	_c.Call.Return(response, err)
	return _c
}

func (_c *MockDeviceInventoryDeviceAPIAPI_ReplaceAttributesExecute_Call) RunAndReturn(run func(r client.ApiReplaceAttributesRequest) (*http.Response, error)) *MockDeviceInventoryDeviceAPIAPI_ReplaceAttributesExecute_Call {
	_c.Call.Return(run)
	return _c
}

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

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

	return mock
}

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

type MockDeviceInventoryFiltersAndSearchInternalAPIAPI_Expecter struct {
	mock *mock.Mock
}

func (_m *MockDeviceInventoryFiltersAndSearchInternalAPIAPI) EXPECT() *MockDeviceInventoryFiltersAndSearchInternalAPIAPI_Expecter {
	return &MockDeviceInventoryFiltersAndSearchInternalAPIAPI_Expecter{mock: &_m.Mock}
}

// GetStatisticsInternal provides a mock function for the type MockDeviceInventoryFiltersAndSearchInternalAPIAPI
func (_mock *MockDeviceInventoryFiltersAndSearchInternalAPIAPI) GetStatisticsInternal(ctx context.Context, tenantId string) client.ApiGetStatisticsInternalRequest {
	ret := _mock.Called(ctx, tenantId)

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

	var r0 client.ApiGetStatisticsInternalRequest
	if returnFunc, ok := ret.Get(0).(func(context.Context, string) client.ApiGetStatisticsInternalRequest); ok {
		r0 = returnFunc(ctx, tenantId)
	} else {
		r0 = ret.Get(0).(client.ApiGetStatisticsInternalRequest)
	}
	return r0
}

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

// GetStatisticsInternal is a helper method to define mock.On call
//   - ctx context.Context
//   - tenantId string
func (_e *MockDeviceInventoryFiltersAndSearchInternalAPIAPI_Expecter) GetStatisticsInternal(ctx interface{}, tenantId interface{}) *MockDeviceInventoryFiltersAndSearchInternalAPIAPI_GetStatisticsInternal_Call {
	return &MockDeviceInventoryFiltersAndSearchInternalAPIAPI_GetStatisticsInternal_Call{Call: _e.mock.On("GetStatisticsInternal", ctx, tenantId)}
}

func (_c *MockDeviceInventoryFiltersAndSearchInternalAPIAPI_GetStatisticsInternal_Call) Run(run func(ctx context.Context, tenantId string)) *MockDeviceInventoryFiltersAndSearchInternalAPIAPI_GetStatisticsInternal_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 *MockDeviceInventoryFiltersAndSearchInternalAPIAPI_GetStatisticsInternal_Call) Return(apiGetStatisticsInternalRequest client.ApiGetStatisticsInternalRequest) *MockDeviceInventoryFiltersAndSearchInternalAPIAPI_GetStatisticsInternal_Call {
	_c.Call.Return(apiGetStatisticsInternalRequest)
	return _c
}

func (_c *MockDeviceInventoryFiltersAndSearchInternalAPIAPI_GetStatisticsInternal_Call) RunAndReturn(run func(ctx context.Context, tenantId string) client.ApiGetStatisticsInternalRequest) *MockDeviceInventoryFiltersAndSearchInternalAPIAPI_GetStatisticsInternal_Call {
	_c.Call.Return(run)
	return _c
}

// GetStatisticsInternalExecute provides a mock function for the type MockDeviceInventoryFiltersAndSearchInternalAPIAPI
func (_mock *MockDeviceInventoryFiltersAndSearchInternalAPIAPI) GetStatisticsInternalExecute(r client.ApiGetStatisticsInternalRequest) (*client.GetStatisticsInternal200Response, *http.Response, error) {
	ret := _mock.Called(r)

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

	var r0 *client.GetStatisticsInternal200Response
	var r1 *http.Response
	var r2 error
	if returnFunc, ok := ret.Get(0).(func(client.ApiGetStatisticsInternalRequest) (*client.GetStatisticsInternal200Response, *http.Response, error)); ok {
		return returnFunc(r)
	}
	if returnFunc, ok := ret.Get(0).(func(client.ApiGetStatisticsInternalRequest) *client.GetStatisticsInternal200Response); ok {
		r0 = returnFunc(r)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*client.GetStatisticsInternal200Response)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(client.ApiGetStatisticsInternalRequest) *http.Response); ok {
		r1 = returnFunc(r)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*http.Response)
		}
	}
	if returnFunc, ok := ret.Get(2).(func(client.ApiGetStatisticsInternalRequest) error); ok {
		r2 = returnFunc(r)
	} else {
		r2 = ret.Error(2)
	}
	return r0, r1, r2
}

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

// GetStatisticsInternalExecute is a helper method to define mock.On call
//   - r client.ApiGetStatisticsInternalRequest
func (_e *MockDeviceInventoryFiltersAndSearchInternalAPIAPI_Expecter) GetStatisticsInternalExecute(r interface{}) *MockDeviceInventoryFiltersAndSearchInternalAPIAPI_GetStatisticsInternalExecute_Call {
	return &MockDeviceInventoryFiltersAndSearchInternalAPIAPI_GetStatisticsInternalExecute_Call{Call: _e.mock.On("GetStatisticsInternalExecute", r)}
}

func (_c *MockDeviceInventoryFiltersAndSearchInternalAPIAPI_GetStatisticsInternalExecute_Call) Run(run func(r client.ApiGetStatisticsInternalRequest)) *MockDeviceInventoryFiltersAndSearchInternalAPIAPI_GetStatisticsInternalExecute_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 client.ApiGetStatisticsInternalRequest
		if args[0] != nil {
			arg0 = args[0].(client.ApiGetStatisticsInternalRequest)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *MockDeviceInventoryFiltersAndSearchInternalAPIAPI_GetStatisticsInternalExecute_Call) Return(getStatisticsInternal200Response *client.GetStatisticsInternal200Response, response *http.Response, err error) *MockDeviceInventoryFiltersAndSearchInternalAPIAPI_GetStatisticsInternalExecute_Call {
	_c.Call.Return(getStatisticsInternal200Response, response, err)
	return _c
}

func (_c *MockDeviceInventoryFiltersAndSearchInternalAPIAPI_GetStatisticsInternalExecute_Call) RunAndReturn(run func(r client.ApiGetStatisticsInternalRequest) (*client.GetStatisticsInternal200Response, *http.Response, error)) *MockDeviceInventoryFiltersAndSearchInternalAPIAPI_GetStatisticsInternalExecute_Call {
	_c.Call.Return(run)
	return _c
}

// InventoryInternalV2SearchDeviceInventories provides a mock function for the type MockDeviceInventoryFiltersAndSearchInternalAPIAPI
func (_mock *MockDeviceInventoryFiltersAndSearchInternalAPIAPI) InventoryInternalV2SearchDeviceInventories(ctx context.Context, tenantId string) client.ApiInventoryInternalV2SearchDeviceInventoriesRequest {
	ret := _mock.Called(ctx, tenantId)

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

	var r0 client.ApiInventoryInternalV2SearchDeviceInventoriesRequest
	if returnFunc, ok := ret.Get(0).(func(context.Context, string) client.ApiInventoryInternalV2SearchDeviceInventoriesRequest); ok {
		r0 = returnFunc(ctx, tenantId)
	} else {
		r0 = ret.Get(0).(client.ApiInventoryInternalV2SearchDeviceInventoriesRequest)
	}
	return r0
}

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

// InventoryInternalV2SearchDeviceInventories is a helper method to define mock.On call
//   - ctx context.Context
//   - tenantId string
func (_e *MockDeviceInventoryFiltersAndSearchInternalAPIAPI_Expecter) InventoryInternalV2SearchDeviceInventories(ctx interface{}, tenantId interface{}) *MockDeviceInventoryFiltersAndSearchInternalAPIAPI_InventoryInternalV2SearchDeviceInventories_Call {
	return &MockDeviceInventoryFiltersAndSearchInternalAPIAPI_InventoryInternalV2SearchDeviceInventories_Call{Call: _e.mock.On("InventoryInternalV2SearchDeviceInventories", ctx, tenantId)}
}

func (_c *MockDeviceInventoryFiltersAndSearchInternalAPIAPI_InventoryInternalV2SearchDeviceInventories_Call) Run(run func(ctx context.Context, tenantId string)) *MockDeviceInventoryFiltersAndSearchInternalAPIAPI_InventoryInternalV2SearchDeviceInventories_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 *MockDeviceInventoryFiltersAndSearchInternalAPIAPI_InventoryInternalV2SearchDeviceInventories_Call) Return(apiInventoryInternalV2SearchDeviceInventoriesRequest client.ApiInventoryInternalV2SearchDeviceInventoriesRequest) *MockDeviceInventoryFiltersAndSearchInternalAPIAPI_InventoryInternalV2SearchDeviceInventories_Call {
	_c.Call.Return(apiInventoryInternalV2SearchDeviceInventoriesRequest)
	return _c
}

func (_c *MockDeviceInventoryFiltersAndSearchInternalAPIAPI_InventoryInternalV2SearchDeviceInventories_Call) RunAndReturn(run func(ctx context.Context, tenantId string) client.ApiInventoryInternalV2SearchDeviceInventoriesRequest) *MockDeviceInventoryFiltersAndSearchInternalAPIAPI_InventoryInternalV2SearchDeviceInventories_Call {
	_c.Call.Return(run)
	return _c
}

// InventoryInternalV2SearchDeviceInventoriesExecute provides a mock function for the type MockDeviceInventoryFiltersAndSearchInternalAPIAPI
func (_mock *MockDeviceInventoryFiltersAndSearchInternalAPIAPI) InventoryInternalV2SearchDeviceInventoriesExecute(r client.ApiInventoryInternalV2SearchDeviceInventoriesRequest) ([]client.DeviceInventoryResponse, *http.Response, error) {
	ret := _mock.Called(r)

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

	var r0 []client.DeviceInventoryResponse
	var r1 *http.Response
	var r2 error
	if returnFunc, ok := ret.Get(0).(func(client.ApiInventoryInternalV2SearchDeviceInventoriesRequest) ([]client.DeviceInventoryResponse, *http.Response, error)); ok {
		return returnFunc(r)
	}
	if returnFunc, ok := ret.Get(0).(func(client.ApiInventoryInternalV2SearchDeviceInventoriesRequest) []client.DeviceInventoryResponse); ok {
		r0 = returnFunc(r)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]client.DeviceInventoryResponse)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(client.ApiInventoryInternalV2SearchDeviceInventoriesRequest) *http.Response); ok {
		r1 = returnFunc(r)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*http.Response)
		}
	}
	if returnFunc, ok := ret.Get(2).(func(client.ApiInventoryInternalV2SearchDeviceInventoriesRequest) error); ok {
		r2 = returnFunc(r)
	} else {
		r2 = ret.Error(2)
	}
	return r0, r1, r2
}

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

// InventoryInternalV2SearchDeviceInventoriesExecute is a helper method to define mock.On call
//   - r client.ApiInventoryInternalV2SearchDeviceInventoriesRequest
func (_e *MockDeviceInventoryFiltersAndSearchInternalAPIAPI_Expecter) InventoryInternalV2SearchDeviceInventoriesExecute(r interface{}) *MockDeviceInventoryFiltersAndSearchInternalAPIAPI_InventoryInternalV2SearchDeviceInventoriesExecute_Call {
	return &MockDeviceInventoryFiltersAndSearchInternalAPIAPI_InventoryInternalV2SearchDeviceInventoriesExecute_Call{Call: _e.mock.On("InventoryInternalV2SearchDeviceInventoriesExecute", r)}
}

func (_c *MockDeviceInventoryFiltersAndSearchInternalAPIAPI_InventoryInternalV2SearchDeviceInventoriesExecute_Call) Run(run func(r client.ApiInventoryInternalV2SearchDeviceInventoriesRequest)) *MockDeviceInventoryFiltersAndSearchInternalAPIAPI_InventoryInternalV2SearchDeviceInventoriesExecute_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 client.ApiInventoryInternalV2SearchDeviceInventoriesRequest
		if args[0] != nil {
			arg0 = args[0].(client.ApiInventoryInternalV2SearchDeviceInventoriesRequest)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *MockDeviceInventoryFiltersAndSearchInternalAPIAPI_InventoryInternalV2SearchDeviceInventoriesExecute_Call) Return(deviceInventoryResponses []client.DeviceInventoryResponse, response *http.Response, err error) *MockDeviceInventoryFiltersAndSearchInternalAPIAPI_InventoryInternalV2SearchDeviceInventoriesExecute_Call {
	_c.Call.Return(deviceInventoryResponses, response, err)
	return _c
}

func (_c *MockDeviceInventoryFiltersAndSearchInternalAPIAPI_InventoryInternalV2SearchDeviceInventoriesExecute_Call) RunAndReturn(run func(r client.ApiInventoryInternalV2SearchDeviceInventoriesRequest) ([]client.DeviceInventoryResponse, *http.Response, error)) *MockDeviceInventoryFiltersAndSearchInternalAPIAPI_InventoryInternalV2SearchDeviceInventoriesExecute_Call {
	_c.Call.Return(run)
	return _c
}

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

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

	return mock
}

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

type MockDeviceInventoryFiltersAndSearchManagementAPIAPI_Expecter struct {
	mock *mock.Mock
}

func (_m *MockDeviceInventoryFiltersAndSearchManagementAPIAPI) EXPECT() *MockDeviceInventoryFiltersAndSearchManagementAPIAPI_Expecter {
	return &MockDeviceInventoryFiltersAndSearchManagementAPIAPI_Expecter{mock: &_m.Mock}
}

// GetFilterableAttributes provides a mock function for the type MockDeviceInventoryFiltersAndSearchManagementAPIAPI
func (_mock *MockDeviceInventoryFiltersAndSearchManagementAPIAPI) GetFilterableAttributes(ctx context.Context) client.ApiGetFilterableAttributesRequest {
	ret := _mock.Called(ctx)

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

	var r0 client.ApiGetFilterableAttributesRequest
	if returnFunc, ok := ret.Get(0).(func(context.Context) client.ApiGetFilterableAttributesRequest); ok {
		r0 = returnFunc(ctx)
	} else {
		r0 = ret.Get(0).(client.ApiGetFilterableAttributesRequest)
	}
	return r0
}

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

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

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

func (_c *MockDeviceInventoryFiltersAndSearchManagementAPIAPI_GetFilterableAttributes_Call) Return(apiGetFilterableAttributesRequest client.ApiGetFilterableAttributesRequest) *MockDeviceInventoryFiltersAndSearchManagementAPIAPI_GetFilterableAttributes_Call {
	_c.Call.Return(apiGetFilterableAttributesRequest)
	return _c
}

func (_c *MockDeviceInventoryFiltersAndSearchManagementAPIAPI_GetFilterableAttributes_Call) RunAndReturn(run func(ctx context.Context) client.ApiGetFilterableAttributesRequest) *MockDeviceInventoryFiltersAndSearchManagementAPIAPI_GetFilterableAttributes_Call {
	_c.Call.Return(run)
	return _c
}

// GetFilterableAttributesExecute provides a mock function for the type MockDeviceInventoryFiltersAndSearchManagementAPIAPI
func (_mock *MockDeviceInventoryFiltersAndSearchManagementAPIAPI) GetFilterableAttributesExecute(r client.ApiGetFilterableAttributesRequest) ([]client.FilterAttribute, *http.Response, error) {
	ret := _mock.Called(r)

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

	var r0 []client.FilterAttribute
	var r1 *http.Response
	var r2 error
	if returnFunc, ok := ret.Get(0).(func(client.ApiGetFilterableAttributesRequest) ([]client.FilterAttribute, *http.Response, error)); ok {
		return returnFunc(r)
	}
	if returnFunc, ok := ret.Get(0).(func(client.ApiGetFilterableAttributesRequest) []client.FilterAttribute); ok {
		r0 = returnFunc(r)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]client.FilterAttribute)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(client.ApiGetFilterableAttributesRequest) *http.Response); ok {
		r1 = returnFunc(r)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*http.Response)
		}
	}
	if returnFunc, ok := ret.Get(2).(func(client.ApiGetFilterableAttributesRequest) error); ok {
		r2 = returnFunc(r)
	} else {
		r2 = ret.Error(2)
	}
	return r0, r1, r2
}

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

// GetFilterableAttributesExecute is a helper method to define mock.On call
//   - r client.ApiGetFilterableAttributesRequest
func (_e *MockDeviceInventoryFiltersAndSearchManagementAPIAPI_Expecter) GetFilterableAttributesExecute(r interface{}) *MockDeviceInventoryFiltersAndSearchManagementAPIAPI_GetFilterableAttributesExecute_Call {
	return &MockDeviceInventoryFiltersAndSearchManagementAPIAPI_GetFilterableAttributesExecute_Call{Call: _e.mock.On("GetFilterableAttributesExecute", r)}
}

func (_c *MockDeviceInventoryFiltersAndSearchManagementAPIAPI_GetFilterableAttributesExecute_Call) Run(run func(r client.ApiGetFilterableAttributesRequest)) *MockDeviceInventoryFiltersAndSearchManagementAPIAPI_GetFilterableAttributesExecute_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 client.ApiGetFilterableAttributesRequest
		if args[0] != nil {
			arg0 = args[0].(client.ApiGetFilterableAttributesRequest)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *MockDeviceInventoryFiltersAndSearchManagementAPIAPI_GetFilterableAttributesExecute_Call) Return(filterAttributes []client.FilterAttribute, response *http.Response, err error) *MockDeviceInventoryFiltersAndSearchManagementAPIAPI_GetFilterableAttributesExecute_Call {
	_c.Call.Return(filterAttributes, response, err)
	return _c
}

func (_c *MockDeviceInventoryFiltersAndSearchManagementAPIAPI_GetFilterableAttributesExecute_Call) RunAndReturn(run func(r client.ApiGetFilterableAttributesRequest) ([]client.FilterAttribute, *http.Response, error)) *MockDeviceInventoryFiltersAndSearchManagementAPIAPI_GetFilterableAttributesExecute_Call {
	_c.Call.Return(run)
	return _c
}

// GetStatistics provides a mock function for the type MockDeviceInventoryFiltersAndSearchManagementAPIAPI
func (_mock *MockDeviceInventoryFiltersAndSearchManagementAPIAPI) GetStatistics(ctx context.Context) client.ApiGetStatisticsRequest {
	ret := _mock.Called(ctx)

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

	var r0 client.ApiGetStatisticsRequest
	if returnFunc, ok := ret.Get(0).(func(context.Context) client.ApiGetStatisticsRequest); ok {
		r0 = returnFunc(ctx)
	} else {
		r0 = ret.Get(0).(client.ApiGetStatisticsRequest)
	}
	return r0
}

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

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

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

func (_c *MockDeviceInventoryFiltersAndSearchManagementAPIAPI_GetStatistics_Call) Return(apiGetStatisticsRequest client.ApiGetStatisticsRequest) *MockDeviceInventoryFiltersAndSearchManagementAPIAPI_GetStatistics_Call {
	_c.Call.Return(apiGetStatisticsRequest)
	return _c
}

func (_c *MockDeviceInventoryFiltersAndSearchManagementAPIAPI_GetStatistics_Call) RunAndReturn(run func(ctx context.Context) client.ApiGetStatisticsRequest) *MockDeviceInventoryFiltersAndSearchManagementAPIAPI_GetStatistics_Call {
	_c.Call.Return(run)
	return _c
}

// GetStatisticsExecute provides a mock function for the type MockDeviceInventoryFiltersAndSearchManagementAPIAPI
func (_mock *MockDeviceInventoryFiltersAndSearchManagementAPIAPI) GetStatisticsExecute(r client.ApiGetStatisticsRequest) (*client.GetStatisticsInternal200Response, *http.Response, error) {
	ret := _mock.Called(r)

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

	var r0 *client.GetStatisticsInternal200Response
	var r1 *http.Response
	var r2 error
	if returnFunc, ok := ret.Get(0).(func(client.ApiGetStatisticsRequest) (*client.GetStatisticsInternal200Response, *http.Response, error)); ok {
		return returnFunc(r)
	}
	if returnFunc, ok := ret.Get(0).(func(client.ApiGetStatisticsRequest) *client.GetStatisticsInternal200Response); ok {
		r0 = returnFunc(r)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*client.GetStatisticsInternal200Response)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(client.ApiGetStatisticsRequest) *http.Response); ok {
		r1 = returnFunc(r)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*http.Response)
		}
	}
	if returnFunc, ok := ret.Get(2).(func(client.ApiGetStatisticsRequest) error); ok {
		r2 = returnFunc(r)
	} else {
		r2 = ret.Error(2)
	}
	return r0, r1, r2
}

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

// GetStatisticsExecute is a helper method to define mock.On call
//   - r client.ApiGetStatisticsRequest
func (_e *MockDeviceInventoryFiltersAndSearchManagementAPIAPI_Expecter) GetStatisticsExecute(r interface{}) *MockDeviceInventoryFiltersAndSearchManagementAPIAPI_GetStatisticsExecute_Call {
	return &MockDeviceInventoryFiltersAndSearchManagementAPIAPI_GetStatisticsExecute_Call{Call: _e.mock.On("GetStatisticsExecute", r)}
}

func (_c *MockDeviceInventoryFiltersAndSearchManagementAPIAPI_GetStatisticsExecute_Call) Run(run func(r client.ApiGetStatisticsRequest)) *MockDeviceInventoryFiltersAndSearchManagementAPIAPI_GetStatisticsExecute_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 client.ApiGetStatisticsRequest
		if args[0] != nil {
			arg0 = args[0].(client.ApiGetStatisticsRequest)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *MockDeviceInventoryFiltersAndSearchManagementAPIAPI_GetStatisticsExecute_Call) Return(getStatisticsInternal200Response *client.GetStatisticsInternal200Response, response *http.Response, err error) *MockDeviceInventoryFiltersAndSearchManagementAPIAPI_GetStatisticsExecute_Call {
	_c.Call.Return(getStatisticsInternal200Response, response, err)
	return _c
}

func (_c *MockDeviceInventoryFiltersAndSearchManagementAPIAPI_GetStatisticsExecute_Call) RunAndReturn(run func(r client.ApiGetStatisticsRequest) (*client.GetStatisticsInternal200Response, *http.Response, error)) *MockDeviceInventoryFiltersAndSearchManagementAPIAPI_GetStatisticsExecute_Call {
	_c.Call.Return(run)
	return _c
}

// InventoryV2SearchDeviceInventories provides a mock function for the type MockDeviceInventoryFiltersAndSearchManagementAPIAPI
func (_mock *MockDeviceInventoryFiltersAndSearchManagementAPIAPI) InventoryV2SearchDeviceInventories(ctx context.Context) client.ApiInventoryV2SearchDeviceInventoriesRequest {
	ret := _mock.Called(ctx)

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

	var r0 client.ApiInventoryV2SearchDeviceInventoriesRequest
	if returnFunc, ok := ret.Get(0).(func(context.Context) client.ApiInventoryV2SearchDeviceInventoriesRequest); ok {
		r0 = returnFunc(ctx)
	} else {
		r0 = ret.Get(0).(client.ApiInventoryV2SearchDeviceInventoriesRequest)
	}
	return r0
}

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

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

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

func (_c *MockDeviceInventoryFiltersAndSearchManagementAPIAPI_InventoryV2SearchDeviceInventories_Call) Return(apiInventoryV2SearchDeviceInventoriesRequest client.ApiInventoryV2SearchDeviceInventoriesRequest) *MockDeviceInventoryFiltersAndSearchManagementAPIAPI_InventoryV2SearchDeviceInventories_Call {
	_c.Call.Return(apiInventoryV2SearchDeviceInventoriesRequest)
	return _c
}

func (_c *MockDeviceInventoryFiltersAndSearchManagementAPIAPI_InventoryV2SearchDeviceInventories_Call) RunAndReturn(run func(ctx context.Context) client.ApiInventoryV2SearchDeviceInventoriesRequest) *MockDeviceInventoryFiltersAndSearchManagementAPIAPI_InventoryV2SearchDeviceInventories_Call {
	_c.Call.Return(run)
	return _c
}

// InventoryV2SearchDeviceInventoriesExecute provides a mock function for the type MockDeviceInventoryFiltersAndSearchManagementAPIAPI
func (_mock *MockDeviceInventoryFiltersAndSearchManagementAPIAPI) InventoryV2SearchDeviceInventoriesExecute(r client.ApiInventoryV2SearchDeviceInventoriesRequest) ([]client.DeviceInventoryResponse, *http.Response, error) {
	ret := _mock.Called(r)

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

	var r0 []client.DeviceInventoryResponse
	var r1 *http.Response
	var r2 error
	if returnFunc, ok := ret.Get(0).(func(client.ApiInventoryV2SearchDeviceInventoriesRequest) ([]client.DeviceInventoryResponse, *http.Response, error)); ok {
		return returnFunc(r)
	}
	if returnFunc, ok := ret.Get(0).(func(client.ApiInventoryV2SearchDeviceInventoriesRequest) []client.DeviceInventoryResponse); ok {
		r0 = returnFunc(r)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]client.DeviceInventoryResponse)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(client.ApiInventoryV2SearchDeviceInventoriesRequest) *http.Response); ok {
		r1 = returnFunc(r)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*http.Response)
		}
	}
	if returnFunc, ok := ret.Get(2).(func(client.ApiInventoryV2SearchDeviceInventoriesRequest) error); ok {
		r2 = returnFunc(r)
	} else {
		r2 = ret.Error(2)
	}
	return r0, r1, r2
}

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

// InventoryV2SearchDeviceInventoriesExecute is a helper method to define mock.On call
//   - r client.ApiInventoryV2SearchDeviceInventoriesRequest
func (_e *MockDeviceInventoryFiltersAndSearchManagementAPIAPI_Expecter) InventoryV2SearchDeviceInventoriesExecute(r interface{}) *MockDeviceInventoryFiltersAndSearchManagementAPIAPI_InventoryV2SearchDeviceInventoriesExecute_Call {
	return &MockDeviceInventoryFiltersAndSearchManagementAPIAPI_InventoryV2SearchDeviceInventoriesExecute_Call{Call: _e.mock.On("InventoryV2SearchDeviceInventoriesExecute", r)}
}

func (_c *MockDeviceInventoryFiltersAndSearchManagementAPIAPI_InventoryV2SearchDeviceInventoriesExecute_Call) Run(run func(r client.ApiInventoryV2SearchDeviceInventoriesRequest)) *MockDeviceInventoryFiltersAndSearchManagementAPIAPI_InventoryV2SearchDeviceInventoriesExecute_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 client.ApiInventoryV2SearchDeviceInventoriesRequest
		if args[0] != nil {
			arg0 = args[0].(client.ApiInventoryV2SearchDeviceInventoriesRequest)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *MockDeviceInventoryFiltersAndSearchManagementAPIAPI_InventoryV2SearchDeviceInventoriesExecute_Call) Return(deviceInventoryResponses []client.DeviceInventoryResponse, response *http.Response, err error) *MockDeviceInventoryFiltersAndSearchManagementAPIAPI_InventoryV2SearchDeviceInventoriesExecute_Call {
	_c.Call.Return(deviceInventoryResponses, response, err)
	return _c
}

func (_c *MockDeviceInventoryFiltersAndSearchManagementAPIAPI_InventoryV2SearchDeviceInventoriesExecute_Call) RunAndReturn(run func(r client.ApiInventoryV2SearchDeviceInventoriesRequest) ([]client.DeviceInventoryResponse, *http.Response, error)) *MockDeviceInventoryFiltersAndSearchManagementAPIAPI_InventoryV2SearchDeviceInventoriesExecute_Call {
	_c.Call.Return(run)
	return _c
}

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

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

	return mock
}

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

type MockDeviceInventoryInternalAPIAPI_Expecter struct {
	mock *mock.Mock
}

func (_m *MockDeviceInventoryInternalAPIAPI) EXPECT() *MockDeviceInventoryInternalAPIAPI_Expecter {
	return &MockDeviceInventoryInternalAPIAPI_Expecter{mock: &_m.Mock}
}

// DeleteDevice provides a mock function for the type MockDeviceInventoryInternalAPIAPI
func (_mock *MockDeviceInventoryInternalAPIAPI) DeleteDevice(ctx context.Context, tenantId string, deviceId string) client.ApiDeleteDeviceRequest {
	ret := _mock.Called(ctx, tenantId, deviceId)

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

	var r0 client.ApiDeleteDeviceRequest
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string) client.ApiDeleteDeviceRequest); ok {
		r0 = returnFunc(ctx, tenantId, deviceId)
	} else {
		r0 = ret.Get(0).(client.ApiDeleteDeviceRequest)
	}
	return r0
}

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

// DeleteDevice is a helper method to define mock.On call
//   - ctx context.Context
//   - tenantId string
//   - deviceId string
func (_e *MockDeviceInventoryInternalAPIAPI_Expecter) DeleteDevice(ctx interface{}, tenantId interface{}, deviceId interface{}) *MockDeviceInventoryInternalAPIAPI_DeleteDevice_Call {
	return &MockDeviceInventoryInternalAPIAPI_DeleteDevice_Call{Call: _e.mock.On("DeleteDevice", ctx, tenantId, deviceId)}
}

func (_c *MockDeviceInventoryInternalAPIAPI_DeleteDevice_Call) Run(run func(ctx context.Context, tenantId string, deviceId string)) *MockDeviceInventoryInternalAPIAPI_DeleteDevice_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)
		}
		run(
			arg0,
			arg1,
			arg2,
		)
	})
	return _c
}

func (_c *MockDeviceInventoryInternalAPIAPI_DeleteDevice_Call) Return(apiDeleteDeviceRequest client.ApiDeleteDeviceRequest) *MockDeviceInventoryInternalAPIAPI_DeleteDevice_Call {
	_c.Call.Return(apiDeleteDeviceRequest)
	return _c
}

func (_c *MockDeviceInventoryInternalAPIAPI_DeleteDevice_Call) RunAndReturn(run func(ctx context.Context, tenantId string, deviceId string) client.ApiDeleteDeviceRequest) *MockDeviceInventoryInternalAPIAPI_DeleteDevice_Call {
	_c.Call.Return(run)
	return _c
}

// DeleteDeviceExecute provides a mock function for the type MockDeviceInventoryInternalAPIAPI
func (_mock *MockDeviceInventoryInternalAPIAPI) DeleteDeviceExecute(r client.ApiDeleteDeviceRequest) (*http.Response, error) {
	ret := _mock.Called(r)

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

	var r0 *http.Response
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(client.ApiDeleteDeviceRequest) (*http.Response, error)); ok {
		return returnFunc(r)
	}
	if returnFunc, ok := ret.Get(0).(func(client.ApiDeleteDeviceRequest) *http.Response); ok {
		r0 = returnFunc(r)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*http.Response)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(client.ApiDeleteDeviceRequest) error); ok {
		r1 = returnFunc(r)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// DeleteDeviceExecute is a helper method to define mock.On call
//   - r client.ApiDeleteDeviceRequest
func (_e *MockDeviceInventoryInternalAPIAPI_Expecter) DeleteDeviceExecute(r interface{}) *MockDeviceInventoryInternalAPIAPI_DeleteDeviceExecute_Call {
	return &MockDeviceInventoryInternalAPIAPI_DeleteDeviceExecute_Call{Call: _e.mock.On("DeleteDeviceExecute", r)}
}

func (_c *MockDeviceInventoryInternalAPIAPI_DeleteDeviceExecute_Call) Run(run func(r client.ApiDeleteDeviceRequest)) *MockDeviceInventoryInternalAPIAPI_DeleteDeviceExecute_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 client.ApiDeleteDeviceRequest
		if args[0] != nil {
			arg0 = args[0].(client.ApiDeleteDeviceRequest)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *MockDeviceInventoryInternalAPIAPI_DeleteDeviceExecute_Call) Return(response *http.Response, err error) *MockDeviceInventoryInternalAPIAPI_DeleteDeviceExecute_Call {
	_c.Call.Return(response, err)
	return _c
}

func (_c *MockDeviceInventoryInternalAPIAPI_DeleteDeviceExecute_Call) RunAndReturn(run func(r client.ApiDeleteDeviceRequest) (*http.Response, error)) *MockDeviceInventoryInternalAPIAPI_DeleteDeviceExecute_Call {
	_c.Call.Return(run)
	return _c
}

// GetDeviceGroups provides a mock function for the type MockDeviceInventoryInternalAPIAPI
func (_mock *MockDeviceInventoryInternalAPIAPI) GetDeviceGroups(ctx context.Context, tenantId string, deviceId string) client.ApiGetDeviceGroupsRequest {
	ret := _mock.Called(ctx, tenantId, deviceId)

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

	var r0 client.ApiGetDeviceGroupsRequest
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string) client.ApiGetDeviceGroupsRequest); ok {
		r0 = returnFunc(ctx, tenantId, deviceId)
	} else {
		r0 = ret.Get(0).(client.ApiGetDeviceGroupsRequest)
	}
	return r0
}

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

// GetDeviceGroups is a helper method to define mock.On call
//   - ctx context.Context
//   - tenantId string
//   - deviceId string
func (_e *MockDeviceInventoryInternalAPIAPI_Expecter) GetDeviceGroups(ctx interface{}, tenantId interface{}, deviceId interface{}) *MockDeviceInventoryInternalAPIAPI_GetDeviceGroups_Call {
	return &MockDeviceInventoryInternalAPIAPI_GetDeviceGroups_Call{Call: _e.mock.On("GetDeviceGroups", ctx, tenantId, deviceId)}
}

func (_c *MockDeviceInventoryInternalAPIAPI_GetDeviceGroups_Call) Run(run func(ctx context.Context, tenantId string, deviceId string)) *MockDeviceInventoryInternalAPIAPI_GetDeviceGroups_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)
		}
		run(
			arg0,
			arg1,
			arg2,
		)
	})
	return _c
}

func (_c *MockDeviceInventoryInternalAPIAPI_GetDeviceGroups_Call) Return(apiGetDeviceGroupsRequest client.ApiGetDeviceGroupsRequest) *MockDeviceInventoryInternalAPIAPI_GetDeviceGroups_Call {
	_c.Call.Return(apiGetDeviceGroupsRequest)
	return _c
}

func (_c *MockDeviceInventoryInternalAPIAPI_GetDeviceGroups_Call) RunAndReturn(run func(ctx context.Context, tenantId string, deviceId string) client.ApiGetDeviceGroupsRequest) *MockDeviceInventoryInternalAPIAPI_GetDeviceGroups_Call {
	_c.Call.Return(run)
	return _c
}

// GetDeviceGroupsExecute provides a mock function for the type MockDeviceInventoryInternalAPIAPI
func (_mock *MockDeviceInventoryInternalAPIAPI) GetDeviceGroupsExecute(r client.ApiGetDeviceGroupsRequest) (*client.Groups, *http.Response, error) {
	ret := _mock.Called(r)

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

	var r0 *client.Groups
	var r1 *http.Response
	var r2 error
	if returnFunc, ok := ret.Get(0).(func(client.ApiGetDeviceGroupsRequest) (*client.Groups, *http.Response, error)); ok {
		return returnFunc(r)
	}
	if returnFunc, ok := ret.Get(0).(func(client.ApiGetDeviceGroupsRequest) *client.Groups); ok {
		r0 = returnFunc(r)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*client.Groups)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(client.ApiGetDeviceGroupsRequest) *http.Response); ok {
		r1 = returnFunc(r)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*http.Response)
		}
	}
	if returnFunc, ok := ret.Get(2).(func(client.ApiGetDeviceGroupsRequest) error); ok {
		r2 = returnFunc(r)
	} else {
		r2 = ret.Error(2)
	}
	return r0, r1, r2
}

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

// GetDeviceGroupsExecute is a helper method to define mock.On call
//   - r client.ApiGetDeviceGroupsRequest
func (_e *MockDeviceInventoryInternalAPIAPI_Expecter) GetDeviceGroupsExecute(r interface{}) *MockDeviceInventoryInternalAPIAPI_GetDeviceGroupsExecute_Call {
	return &MockDeviceInventoryInternalAPIAPI_GetDeviceGroupsExecute_Call{Call: _e.mock.On("GetDeviceGroupsExecute", r)}
}

func (_c *MockDeviceInventoryInternalAPIAPI_GetDeviceGroupsExecute_Call) Run(run func(r client.ApiGetDeviceGroupsRequest)) *MockDeviceInventoryInternalAPIAPI_GetDeviceGroupsExecute_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 client.ApiGetDeviceGroupsRequest
		if args[0] != nil {
			arg0 = args[0].(client.ApiGetDeviceGroupsRequest)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *MockDeviceInventoryInternalAPIAPI_GetDeviceGroupsExecute_Call) Return(groups *client.Groups, response *http.Response, err error) *MockDeviceInventoryInternalAPIAPI_GetDeviceGroupsExecute_Call {
	_c.Call.Return(groups, response, err)
	return _c
}

func (_c *MockDeviceInventoryInternalAPIAPI_GetDeviceGroupsExecute_Call) RunAndReturn(run func(r client.ApiGetDeviceGroupsRequest) (*client.Groups, *http.Response, error)) *MockDeviceInventoryInternalAPIAPI_GetDeviceGroupsExecute_Call {
	_c.Call.Return(run)
	return _c
}

// InitializeDevice provides a mock function for the type MockDeviceInventoryInternalAPIAPI
func (_mock *MockDeviceInventoryInternalAPIAPI) InitializeDevice(ctx context.Context, tenantId string) client.ApiInitializeDeviceRequest {
	ret := _mock.Called(ctx, tenantId)

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

	var r0 client.ApiInitializeDeviceRequest
	if returnFunc, ok := ret.Get(0).(func(context.Context, string) client.ApiInitializeDeviceRequest); ok {
		r0 = returnFunc(ctx, tenantId)
	} else {
		r0 = ret.Get(0).(client.ApiInitializeDeviceRequest)
	}
	return r0
}

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

// InitializeDevice is a helper method to define mock.On call
//   - ctx context.Context
//   - tenantId string
func (_e *MockDeviceInventoryInternalAPIAPI_Expecter) InitializeDevice(ctx interface{}, tenantId interface{}) *MockDeviceInventoryInternalAPIAPI_InitializeDevice_Call {
	return &MockDeviceInventoryInternalAPIAPI_InitializeDevice_Call{Call: _e.mock.On("InitializeDevice", ctx, tenantId)}
}

func (_c *MockDeviceInventoryInternalAPIAPI_InitializeDevice_Call) Run(run func(ctx context.Context, tenantId string)) *MockDeviceInventoryInternalAPIAPI_InitializeDevice_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 *MockDeviceInventoryInternalAPIAPI_InitializeDevice_Call) Return(apiInitializeDeviceRequest client.ApiInitializeDeviceRequest) *MockDeviceInventoryInternalAPIAPI_InitializeDevice_Call {
	_c.Call.Return(apiInitializeDeviceRequest)
	return _c
}

func (_c *MockDeviceInventoryInternalAPIAPI_InitializeDevice_Call) RunAndReturn(run func(ctx context.Context, tenantId string) client.ApiInitializeDeviceRequest) *MockDeviceInventoryInternalAPIAPI_InitializeDevice_Call {
	_c.Call.Return(run)
	return _c
}

// InitializeDeviceExecute provides a mock function for the type MockDeviceInventoryInternalAPIAPI
func (_mock *MockDeviceInventoryInternalAPIAPI) InitializeDeviceExecute(r client.ApiInitializeDeviceRequest) (*http.Response, error) {
	ret := _mock.Called(r)

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

	var r0 *http.Response
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(client.ApiInitializeDeviceRequest) (*http.Response, error)); ok {
		return returnFunc(r)
	}
	if returnFunc, ok := ret.Get(0).(func(client.ApiInitializeDeviceRequest) *http.Response); ok {
		r0 = returnFunc(r)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*http.Response)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(client.ApiInitializeDeviceRequest) error); ok {
		r1 = returnFunc(r)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// InitializeDeviceExecute is a helper method to define mock.On call
//   - r client.ApiInitializeDeviceRequest
func (_e *MockDeviceInventoryInternalAPIAPI_Expecter) InitializeDeviceExecute(r interface{}) *MockDeviceInventoryInternalAPIAPI_InitializeDeviceExecute_Call {
	return &MockDeviceInventoryInternalAPIAPI_InitializeDeviceExecute_Call{Call: _e.mock.On("InitializeDeviceExecute", r)}
}

func (_c *MockDeviceInventoryInternalAPIAPI_InitializeDeviceExecute_Call) Run(run func(r client.ApiInitializeDeviceRequest)) *MockDeviceInventoryInternalAPIAPI_InitializeDeviceExecute_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 client.ApiInitializeDeviceRequest
		if args[0] != nil {
			arg0 = args[0].(client.ApiInitializeDeviceRequest)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *MockDeviceInventoryInternalAPIAPI_InitializeDeviceExecute_Call) Return(response *http.Response, err error) *MockDeviceInventoryInternalAPIAPI_InitializeDeviceExecute_Call {
	_c.Call.Return(response, err)
	return _c
}

func (_c *MockDeviceInventoryInternalAPIAPI_InitializeDeviceExecute_Call) RunAndReturn(run func(r client.ApiInitializeDeviceRequest) (*http.Response, error)) *MockDeviceInventoryInternalAPIAPI_InitializeDeviceExecute_Call {
	_c.Call.Return(run)
	return _c
}

// InventoryInternalCheckHealth provides a mock function for the type MockDeviceInventoryInternalAPIAPI
func (_mock *MockDeviceInventoryInternalAPIAPI) InventoryInternalCheckHealth(ctx context.Context) client.ApiInventoryInternalCheckHealthRequest {
	ret := _mock.Called(ctx)

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

	var r0 client.ApiInventoryInternalCheckHealthRequest
	if returnFunc, ok := ret.Get(0).(func(context.Context) client.ApiInventoryInternalCheckHealthRequest); ok {
		r0 = returnFunc(ctx)
	} else {
		r0 = ret.Get(0).(client.ApiInventoryInternalCheckHealthRequest)
	}
	return r0
}

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

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

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

func (_c *MockDeviceInventoryInternalAPIAPI_InventoryInternalCheckHealth_Call) Return(apiInventoryInternalCheckHealthRequest client.ApiInventoryInternalCheckHealthRequest) *MockDeviceInventoryInternalAPIAPI_InventoryInternalCheckHealth_Call {
	_c.Call.Return(apiInventoryInternalCheckHealthRequest)
	return _c
}

func (_c *MockDeviceInventoryInternalAPIAPI_InventoryInternalCheckHealth_Call) RunAndReturn(run func(ctx context.Context) client.ApiInventoryInternalCheckHealthRequest) *MockDeviceInventoryInternalAPIAPI_InventoryInternalCheckHealth_Call {
	_c.Call.Return(run)
	return _c
}

// InventoryInternalCheckHealthExecute provides a mock function for the type MockDeviceInventoryInternalAPIAPI
func (_mock *MockDeviceInventoryInternalAPIAPI) InventoryInternalCheckHealthExecute(r client.ApiInventoryInternalCheckHealthRequest) (*http.Response, error) {
	ret := _mock.Called(r)

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

	var r0 *http.Response
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(client.ApiInventoryInternalCheckHealthRequest) (*http.Response, error)); ok {
		return returnFunc(r)
	}
	if returnFunc, ok := ret.Get(0).(func(client.ApiInventoryInternalCheckHealthRequest) *http.Response); ok {
		r0 = returnFunc(r)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*http.Response)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(client.ApiInventoryInternalCheckHealthRequest) error); ok {
		r1 = returnFunc(r)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// InventoryInternalCheckHealthExecute is a helper method to define mock.On call
//   - r client.ApiInventoryInternalCheckHealthRequest
func (_e *MockDeviceInventoryInternalAPIAPI_Expecter) InventoryInternalCheckHealthExecute(r interface{}) *MockDeviceInventoryInternalAPIAPI_InventoryInternalCheckHealthExecute_Call {
	return &MockDeviceInventoryInternalAPIAPI_InventoryInternalCheckHealthExecute_Call{Call: _e.mock.On("InventoryInternalCheckHealthExecute", r)}
}

func (_c *MockDeviceInventoryInternalAPIAPI_InventoryInternalCheckHealthExecute_Call) Run(run func(r client.ApiInventoryInternalCheckHealthRequest)) *MockDeviceInventoryInternalAPIAPI_InventoryInternalCheckHealthExecute_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 client.ApiInventoryInternalCheckHealthRequest
		if args[0] != nil {
			arg0 = args[0].(client.ApiInventoryInternalCheckHealthRequest)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *MockDeviceInventoryInternalAPIAPI_InventoryInternalCheckHealthExecute_Call) Return(response *http.Response, err error) *MockDeviceInventoryInternalAPIAPI_InventoryInternalCheckHealthExecute_Call {
	_c.Call.Return(response, err)
	return _c
}

func (_c *MockDeviceInventoryInternalAPIAPI_InventoryInternalCheckHealthExecute_Call) RunAndReturn(run func(r client.ApiInventoryInternalCheckHealthRequest) (*http.Response, error)) *MockDeviceInventoryInternalAPIAPI_InventoryInternalCheckHealthExecute_Call {
	_c.Call.Return(run)
	return _c
}

// InventoryInternalCheckLiveliness provides a mock function for the type MockDeviceInventoryInternalAPIAPI
func (_mock *MockDeviceInventoryInternalAPIAPI) InventoryInternalCheckLiveliness(ctx context.Context) client.ApiInventoryInternalCheckLivelinessRequest {
	ret := _mock.Called(ctx)

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

	var r0 client.ApiInventoryInternalCheckLivelinessRequest
	if returnFunc, ok := ret.Get(0).(func(context.Context) client.ApiInventoryInternalCheckLivelinessRequest); ok {
		r0 = returnFunc(ctx)
	} else {
		r0 = ret.Get(0).(client.ApiInventoryInternalCheckLivelinessRequest)
	}
	return r0
}

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

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

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

func (_c *MockDeviceInventoryInternalAPIAPI_InventoryInternalCheckLiveliness_Call) Return(apiInventoryInternalCheckLivelinessRequest client.ApiInventoryInternalCheckLivelinessRequest) *MockDeviceInventoryInternalAPIAPI_InventoryInternalCheckLiveliness_Call {
	_c.Call.Return(apiInventoryInternalCheckLivelinessRequest)
	return _c
}

func (_c *MockDeviceInventoryInternalAPIAPI_InventoryInternalCheckLiveliness_Call) RunAndReturn(run func(ctx context.Context) client.ApiInventoryInternalCheckLivelinessRequest) *MockDeviceInventoryInternalAPIAPI_InventoryInternalCheckLiveliness_Call {
	_c.Call.Return(run)
	return _c
}

// InventoryInternalCheckLivelinessExecute provides a mock function for the type MockDeviceInventoryInternalAPIAPI
func (_mock *MockDeviceInventoryInternalAPIAPI) InventoryInternalCheckLivelinessExecute(r client.ApiInventoryInternalCheckLivelinessRequest) (*http.Response, error) {
	ret := _mock.Called(r)

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

	var r0 *http.Response
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(client.ApiInventoryInternalCheckLivelinessRequest) (*http.Response, error)); ok {
		return returnFunc(r)
	}
	if returnFunc, ok := ret.Get(0).(func(client.ApiInventoryInternalCheckLivelinessRequest) *http.Response); ok {
		r0 = returnFunc(r)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*http.Response)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(client.ApiInventoryInternalCheckLivelinessRequest) error); ok {
		r1 = returnFunc(r)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// InventoryInternalCheckLivelinessExecute is a helper method to define mock.On call
//   - r client.ApiInventoryInternalCheckLivelinessRequest
func (_e *MockDeviceInventoryInternalAPIAPI_Expecter) InventoryInternalCheckLivelinessExecute(r interface{}) *MockDeviceInventoryInternalAPIAPI_InventoryInternalCheckLivelinessExecute_Call {
	return &MockDeviceInventoryInternalAPIAPI_InventoryInternalCheckLivelinessExecute_Call{Call: _e.mock.On("InventoryInternalCheckLivelinessExecute", r)}
}

func (_c *MockDeviceInventoryInternalAPIAPI_InventoryInternalCheckLivelinessExecute_Call) Run(run func(r client.ApiInventoryInternalCheckLivelinessRequest)) *MockDeviceInventoryInternalAPIAPI_InventoryInternalCheckLivelinessExecute_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 client.ApiInventoryInternalCheckLivelinessRequest
		if args[0] != nil {
			arg0 = args[0].(client.ApiInventoryInternalCheckLivelinessRequest)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *MockDeviceInventoryInternalAPIAPI_InventoryInternalCheckLivelinessExecute_Call) Return(response *http.Response, err error) *MockDeviceInventoryInternalAPIAPI_InventoryInternalCheckLivelinessExecute_Call {
	_c.Call.Return(response, err)
	return _c
}

func (_c *MockDeviceInventoryInternalAPIAPI_InventoryInternalCheckLivelinessExecute_Call) RunAndReturn(run func(r client.ApiInventoryInternalCheckLivelinessRequest) (*http.Response, error)) *MockDeviceInventoryInternalAPIAPI_InventoryInternalCheckLivelinessExecute_Call {
	_c.Call.Return(run)
	return _c
}

// InventoryInternalCreateTenant provides a mock function for the type MockDeviceInventoryInternalAPIAPI
func (_mock *MockDeviceInventoryInternalAPIAPI) InventoryInternalCreateTenant(ctx context.Context) client.ApiInventoryInternalCreateTenantRequest {
	ret := _mock.Called(ctx)

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

	var r0 client.ApiInventoryInternalCreateTenantRequest
	if returnFunc, ok := ret.Get(0).(func(context.Context) client.ApiInventoryInternalCreateTenantRequest); ok {
		r0 = returnFunc(ctx)
	} else {
		r0 = ret.Get(0).(client.ApiInventoryInternalCreateTenantRequest)
	}
	return r0
}

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

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

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

func (_c *MockDeviceInventoryInternalAPIAPI_InventoryInternalCreateTenant_Call) Return(apiInventoryInternalCreateTenantRequest client.ApiInventoryInternalCreateTenantRequest) *MockDeviceInventoryInternalAPIAPI_InventoryInternalCreateTenant_Call {
	_c.Call.Return(apiInventoryInternalCreateTenantRequest)
	return _c
}

func (_c *MockDeviceInventoryInternalAPIAPI_InventoryInternalCreateTenant_Call) RunAndReturn(run func(ctx context.Context) client.ApiInventoryInternalCreateTenantRequest) *MockDeviceInventoryInternalAPIAPI_InventoryInternalCreateTenant_Call {
	_c.Call.Return(run)
	return _c
}

// InventoryInternalCreateTenantExecute provides a mock function for the type MockDeviceInventoryInternalAPIAPI
func (_mock *MockDeviceInventoryInternalAPIAPI) InventoryInternalCreateTenantExecute(r client.ApiInventoryInternalCreateTenantRequest) (*http.Response, error) {
	ret := _mock.Called(r)

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

	var r0 *http.Response
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(client.ApiInventoryInternalCreateTenantRequest) (*http.Response, error)); ok {
		return returnFunc(r)
	}
	if returnFunc, ok := ret.Get(0).(func(client.ApiInventoryInternalCreateTenantRequest) *http.Response); ok {
		r0 = returnFunc(r)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*http.Response)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(client.ApiInventoryInternalCreateTenantRequest) error); ok {
		r1 = returnFunc(r)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// InventoryInternalCreateTenantExecute is a helper method to define mock.On call
//   - r client.ApiInventoryInternalCreateTenantRequest
func (_e *MockDeviceInventoryInternalAPIAPI_Expecter) InventoryInternalCreateTenantExecute(r interface{}) *MockDeviceInventoryInternalAPIAPI_InventoryInternalCreateTenantExecute_Call {
	return &MockDeviceInventoryInternalAPIAPI_InventoryInternalCreateTenantExecute_Call{Call: _e.mock.On("InventoryInternalCreateTenantExecute", r)}
}

func (_c *MockDeviceInventoryInternalAPIAPI_InventoryInternalCreateTenantExecute_Call) Run(run func(r client.ApiInventoryInternalCreateTenantRequest)) *MockDeviceInventoryInternalAPIAPI_InventoryInternalCreateTenantExecute_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 client.ApiInventoryInternalCreateTenantRequest
		if args[0] != nil {
			arg0 = args[0].(client.ApiInventoryInternalCreateTenantRequest)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *MockDeviceInventoryInternalAPIAPI_InventoryInternalCreateTenantExecute_Call) Return(response *http.Response, err error) *MockDeviceInventoryInternalAPIAPI_InventoryInternalCreateTenantExecute_Call {
	_c.Call.Return(response, err)
	return _c
}

func (_c *MockDeviceInventoryInternalAPIAPI_InventoryInternalCreateTenantExecute_Call) RunAndReturn(run func(r client.ApiInventoryInternalCreateTenantRequest) (*http.Response, error)) *MockDeviceInventoryInternalAPIAPI_InventoryInternalCreateTenantExecute_Call {
	_c.Call.Return(run)
	return _c
}

// StartReIndexing provides a mock function for the type MockDeviceInventoryInternalAPIAPI
func (_mock *MockDeviceInventoryInternalAPIAPI) StartReIndexing(ctx context.Context, deviceId string, tenantId string) client.ApiStartReIndexingRequest {
	ret := _mock.Called(ctx, deviceId, tenantId)

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

	var r0 client.ApiStartReIndexingRequest
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string) client.ApiStartReIndexingRequest); ok {
		r0 = returnFunc(ctx, deviceId, tenantId)
	} else {
		r0 = ret.Get(0).(client.ApiStartReIndexingRequest)
	}
	return r0
}

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

// StartReIndexing is a helper method to define mock.On call
//   - ctx context.Context
//   - deviceId string
//   - tenantId string
func (_e *MockDeviceInventoryInternalAPIAPI_Expecter) StartReIndexing(ctx interface{}, deviceId interface{}, tenantId interface{}) *MockDeviceInventoryInternalAPIAPI_StartReIndexing_Call {
	return &MockDeviceInventoryInternalAPIAPI_StartReIndexing_Call{Call: _e.mock.On("StartReIndexing", ctx, deviceId, tenantId)}
}

func (_c *MockDeviceInventoryInternalAPIAPI_StartReIndexing_Call) Run(run func(ctx context.Context, deviceId string, tenantId string)) *MockDeviceInventoryInternalAPIAPI_StartReIndexing_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)
		}
		run(
			arg0,
			arg1,
			arg2,
		)
	})
	return _c
}

func (_c *MockDeviceInventoryInternalAPIAPI_StartReIndexing_Call) Return(apiStartReIndexingRequest client.ApiStartReIndexingRequest) *MockDeviceInventoryInternalAPIAPI_StartReIndexing_Call {
	_c.Call.Return(apiStartReIndexingRequest)
	return _c
}

func (_c *MockDeviceInventoryInternalAPIAPI_StartReIndexing_Call) RunAndReturn(run func(ctx context.Context, deviceId string, tenantId string) client.ApiStartReIndexingRequest) *MockDeviceInventoryInternalAPIAPI_StartReIndexing_Call {
	_c.Call.Return(run)
	return _c
}

// StartReIndexingExecute provides a mock function for the type MockDeviceInventoryInternalAPIAPI
func (_mock *MockDeviceInventoryInternalAPIAPI) StartReIndexingExecute(r client.ApiStartReIndexingRequest) (*http.Response, error) {
	ret := _mock.Called(r)

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

	var r0 *http.Response
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(client.ApiStartReIndexingRequest) (*http.Response, error)); ok {
		return returnFunc(r)
	}
	if returnFunc, ok := ret.Get(0).(func(client.ApiStartReIndexingRequest) *http.Response); ok {
		r0 = returnFunc(r)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*http.Response)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(client.ApiStartReIndexingRequest) error); ok {
		r1 = returnFunc(r)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// StartReIndexingExecute is a helper method to define mock.On call
//   - r client.ApiStartReIndexingRequest
func (_e *MockDeviceInventoryInternalAPIAPI_Expecter) StartReIndexingExecute(r interface{}) *MockDeviceInventoryInternalAPIAPI_StartReIndexingExecute_Call {
	return &MockDeviceInventoryInternalAPIAPI_StartReIndexingExecute_Call{Call: _e.mock.On("StartReIndexingExecute", r)}
}

func (_c *MockDeviceInventoryInternalAPIAPI_StartReIndexingExecute_Call) Run(run func(r client.ApiStartReIndexingRequest)) *MockDeviceInventoryInternalAPIAPI_StartReIndexingExecute_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 client.ApiStartReIndexingRequest
		if args[0] != nil {
			arg0 = args[0].(client.ApiStartReIndexingRequest)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *MockDeviceInventoryInternalAPIAPI_StartReIndexingExecute_Call) Return(response *http.Response, err error) *MockDeviceInventoryInternalAPIAPI_StartReIndexingExecute_Call {
	_c.Call.Return(response, err)
	return _c
}

func (_c *MockDeviceInventoryInternalAPIAPI_StartReIndexingExecute_Call) RunAndReturn(run func(r client.ApiStartReIndexingRequest) (*http.Response, error)) *MockDeviceInventoryInternalAPIAPI_StartReIndexingExecute_Call {
	_c.Call.Return(run)
	return _c
}

// UpdateInventoryForADevice provides a mock function for the type MockDeviceInventoryInternalAPIAPI
func (_mock *MockDeviceInventoryInternalAPIAPI) UpdateInventoryForADevice(ctx context.Context, tenantId string, deviceId string, scope string) client.ApiUpdateInventoryForADeviceRequest {
	ret := _mock.Called(ctx, tenantId, deviceId, scope)

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

	var r0 client.ApiUpdateInventoryForADeviceRequest
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, string) client.ApiUpdateInventoryForADeviceRequest); ok {
		r0 = returnFunc(ctx, tenantId, deviceId, scope)
	} else {
		r0 = ret.Get(0).(client.ApiUpdateInventoryForADeviceRequest)
	}
	return r0
}

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

// UpdateInventoryForADevice is a helper method to define mock.On call
//   - ctx context.Context
//   - tenantId string
//   - deviceId string
//   - scope string
func (_e *MockDeviceInventoryInternalAPIAPI_Expecter) UpdateInventoryForADevice(ctx interface{}, tenantId interface{}, deviceId interface{}, scope interface{}) *MockDeviceInventoryInternalAPIAPI_UpdateInventoryForADevice_Call {
	return &MockDeviceInventoryInternalAPIAPI_UpdateInventoryForADevice_Call{Call: _e.mock.On("UpdateInventoryForADevice", ctx, tenantId, deviceId, scope)}
}

func (_c *MockDeviceInventoryInternalAPIAPI_UpdateInventoryForADevice_Call) Run(run func(ctx context.Context, tenantId string, deviceId string, scope string)) *MockDeviceInventoryInternalAPIAPI_UpdateInventoryForADevice_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 string
		if args[3] != nil {
			arg3 = args[3].(string)
		}
		run(
			arg0,
			arg1,
			arg2,
			arg3,
		)
	})
	return _c
}

func (_c *MockDeviceInventoryInternalAPIAPI_UpdateInventoryForADevice_Call) Return(apiUpdateInventoryForADeviceRequest client.ApiUpdateInventoryForADeviceRequest) *MockDeviceInventoryInternalAPIAPI_UpdateInventoryForADevice_Call {
	_c.Call.Return(apiUpdateInventoryForADeviceRequest)
	return _c
}

func (_c *MockDeviceInventoryInternalAPIAPI_UpdateInventoryForADevice_Call) RunAndReturn(run func(ctx context.Context, tenantId string, deviceId string, scope string) client.ApiUpdateInventoryForADeviceRequest) *MockDeviceInventoryInternalAPIAPI_UpdateInventoryForADevice_Call {
	_c.Call.Return(run)
	return _c
}

// UpdateInventoryForADeviceExecute provides a mock function for the type MockDeviceInventoryInternalAPIAPI
func (_mock *MockDeviceInventoryInternalAPIAPI) UpdateInventoryForADeviceExecute(r client.ApiUpdateInventoryForADeviceRequest) (*http.Response, error) {
	ret := _mock.Called(r)

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

	var r0 *http.Response
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(client.ApiUpdateInventoryForADeviceRequest) (*http.Response, error)); ok {
		return returnFunc(r)
	}
	if returnFunc, ok := ret.Get(0).(func(client.ApiUpdateInventoryForADeviceRequest) *http.Response); ok {
		r0 = returnFunc(r)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*http.Response)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(client.ApiUpdateInventoryForADeviceRequest) error); ok {
		r1 = returnFunc(r)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// UpdateInventoryForADeviceExecute is a helper method to define mock.On call
//   - r client.ApiUpdateInventoryForADeviceRequest
func (_e *MockDeviceInventoryInternalAPIAPI_Expecter) UpdateInventoryForADeviceExecute(r interface{}) *MockDeviceInventoryInternalAPIAPI_UpdateInventoryForADeviceExecute_Call {
	return &MockDeviceInventoryInternalAPIAPI_UpdateInventoryForADeviceExecute_Call{Call: _e.mock.On("UpdateInventoryForADeviceExecute", r)}
}

func (_c *MockDeviceInventoryInternalAPIAPI_UpdateInventoryForADeviceExecute_Call) Run(run func(r client.ApiUpdateInventoryForADeviceRequest)) *MockDeviceInventoryInternalAPIAPI_UpdateInventoryForADeviceExecute_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 client.ApiUpdateInventoryForADeviceRequest
		if args[0] != nil {
			arg0 = args[0].(client.ApiUpdateInventoryForADeviceRequest)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *MockDeviceInventoryInternalAPIAPI_UpdateInventoryForADeviceExecute_Call) Return(response *http.Response, err error) *MockDeviceInventoryInternalAPIAPI_UpdateInventoryForADeviceExecute_Call {
	_c.Call.Return(response, err)
	return _c
}

func (_c *MockDeviceInventoryInternalAPIAPI_UpdateInventoryForADeviceExecute_Call) RunAndReturn(run func(r client.ApiUpdateInventoryForADeviceRequest) (*http.Response, error)) *MockDeviceInventoryInternalAPIAPI_UpdateInventoryForADeviceExecute_Call {
	_c.Call.Return(run)
	return _c
}

// UpdateInventoryForADeviceScopeWise provides a mock function for the type MockDeviceInventoryInternalAPIAPI
func (_mock *MockDeviceInventoryInternalAPIAPI) UpdateInventoryForADeviceScopeWise(ctx context.Context, tenantId string, deviceId string) client.ApiUpdateInventoryForADeviceScopeWiseRequest {
	ret := _mock.Called(ctx, tenantId, deviceId)

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

	var r0 client.ApiUpdateInventoryForADeviceScopeWiseRequest
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string) client.ApiUpdateInventoryForADeviceScopeWiseRequest); ok {
		r0 = returnFunc(ctx, tenantId, deviceId)
	} else {
		r0 = ret.Get(0).(client.ApiUpdateInventoryForADeviceScopeWiseRequest)
	}
	return r0
}

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

// UpdateInventoryForADeviceScopeWise is a helper method to define mock.On call
//   - ctx context.Context
//   - tenantId string
//   - deviceId string
func (_e *MockDeviceInventoryInternalAPIAPI_Expecter) UpdateInventoryForADeviceScopeWise(ctx interface{}, tenantId interface{}, deviceId interface{}) *MockDeviceInventoryInternalAPIAPI_UpdateInventoryForADeviceScopeWise_Call {
	return &MockDeviceInventoryInternalAPIAPI_UpdateInventoryForADeviceScopeWise_Call{Call: _e.mock.On("UpdateInventoryForADeviceScopeWise", ctx, tenantId, deviceId)}
}

func (_c *MockDeviceInventoryInternalAPIAPI_UpdateInventoryForADeviceScopeWise_Call) Run(run func(ctx context.Context, tenantId string, deviceId string)) *MockDeviceInventoryInternalAPIAPI_UpdateInventoryForADeviceScopeWise_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)
		}
		run(
			arg0,
			arg1,
			arg2,
		)
	})
	return _c
}

func (_c *MockDeviceInventoryInternalAPIAPI_UpdateInventoryForADeviceScopeWise_Call) Return(apiUpdateInventoryForADeviceScopeWiseRequest client.ApiUpdateInventoryForADeviceScopeWiseRequest) *MockDeviceInventoryInternalAPIAPI_UpdateInventoryForADeviceScopeWise_Call {
	_c.Call.Return(apiUpdateInventoryForADeviceScopeWiseRequest)
	return _c
}

func (_c *MockDeviceInventoryInternalAPIAPI_UpdateInventoryForADeviceScopeWise_Call) RunAndReturn(run func(ctx context.Context, tenantId string, deviceId string) client.ApiUpdateInventoryForADeviceScopeWiseRequest) *MockDeviceInventoryInternalAPIAPI_UpdateInventoryForADeviceScopeWise_Call {
	_c.Call.Return(run)
	return _c
}

// UpdateInventoryForADeviceScopeWiseExecute provides a mock function for the type MockDeviceInventoryInternalAPIAPI
func (_mock *MockDeviceInventoryInternalAPIAPI) UpdateInventoryForADeviceScopeWiseExecute(r client.ApiUpdateInventoryForADeviceScopeWiseRequest) (*http.Response, error) {
	ret := _mock.Called(r)

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

	var r0 *http.Response
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(client.ApiUpdateInventoryForADeviceScopeWiseRequest) (*http.Response, error)); ok {
		return returnFunc(r)
	}
	if returnFunc, ok := ret.Get(0).(func(client.ApiUpdateInventoryForADeviceScopeWiseRequest) *http.Response); ok {
		r0 = returnFunc(r)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*http.Response)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(client.ApiUpdateInventoryForADeviceScopeWiseRequest) error); ok {
		r1 = returnFunc(r)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// UpdateInventoryForADeviceScopeWiseExecute is a helper method to define mock.On call
//   - r client.ApiUpdateInventoryForADeviceScopeWiseRequest
func (_e *MockDeviceInventoryInternalAPIAPI_Expecter) UpdateInventoryForADeviceScopeWiseExecute(r interface{}) *MockDeviceInventoryInternalAPIAPI_UpdateInventoryForADeviceScopeWiseExecute_Call {
	return &MockDeviceInventoryInternalAPIAPI_UpdateInventoryForADeviceScopeWiseExecute_Call{Call: _e.mock.On("UpdateInventoryForADeviceScopeWiseExecute", r)}
}

func (_c *MockDeviceInventoryInternalAPIAPI_UpdateInventoryForADeviceScopeWiseExecute_Call) Run(run func(r client.ApiUpdateInventoryForADeviceScopeWiseRequest)) *MockDeviceInventoryInternalAPIAPI_UpdateInventoryForADeviceScopeWiseExecute_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 client.ApiUpdateInventoryForADeviceScopeWiseRequest
		if args[0] != nil {
			arg0 = args[0].(client.ApiUpdateInventoryForADeviceScopeWiseRequest)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *MockDeviceInventoryInternalAPIAPI_UpdateInventoryForADeviceScopeWiseExecute_Call) Return(response *http.Response, err error) *MockDeviceInventoryInternalAPIAPI_UpdateInventoryForADeviceScopeWiseExecute_Call {
	_c.Call.Return(response, err)
	return _c
}

func (_c *MockDeviceInventoryInternalAPIAPI_UpdateInventoryForADeviceScopeWiseExecute_Call) RunAndReturn(run func(r client.ApiUpdateInventoryForADeviceScopeWiseRequest) (*http.Response, error)) *MockDeviceInventoryInternalAPIAPI_UpdateInventoryForADeviceScopeWiseExecute_Call {
	_c.Call.Return(run)
	return _c
}

// UpdateStatusOfDevices provides a mock function for the type MockDeviceInventoryInternalAPIAPI
func (_mock *MockDeviceInventoryInternalAPIAPI) UpdateStatusOfDevices(ctx context.Context, tenantId string, status string) client.ApiUpdateStatusOfDevicesRequest {
	ret := _mock.Called(ctx, tenantId, status)

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

	var r0 client.ApiUpdateStatusOfDevicesRequest
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string) client.ApiUpdateStatusOfDevicesRequest); ok {
		r0 = returnFunc(ctx, tenantId, status)
	} else {
		r0 = ret.Get(0).(client.ApiUpdateStatusOfDevicesRequest)
	}
	return r0
}

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

// UpdateStatusOfDevices is a helper method to define mock.On call
//   - ctx context.Context
//   - tenantId string
//   - status string
func (_e *MockDeviceInventoryInternalAPIAPI_Expecter) UpdateStatusOfDevices(ctx interface{}, tenantId interface{}, status interface{}) *MockDeviceInventoryInternalAPIAPI_UpdateStatusOfDevices_Call {
	return &MockDeviceInventoryInternalAPIAPI_UpdateStatusOfDevices_Call{Call: _e.mock.On("UpdateStatusOfDevices", ctx, tenantId, status)}
}

func (_c *MockDeviceInventoryInternalAPIAPI_UpdateStatusOfDevices_Call) Run(run func(ctx context.Context, tenantId string, status string)) *MockDeviceInventoryInternalAPIAPI_UpdateStatusOfDevices_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)
		}
		run(
			arg0,
			arg1,
			arg2,
		)
	})
	return _c
}

func (_c *MockDeviceInventoryInternalAPIAPI_UpdateStatusOfDevices_Call) Return(apiUpdateStatusOfDevicesRequest client.ApiUpdateStatusOfDevicesRequest) *MockDeviceInventoryInternalAPIAPI_UpdateStatusOfDevices_Call {
	_c.Call.Return(apiUpdateStatusOfDevicesRequest)
	return _c
}

func (_c *MockDeviceInventoryInternalAPIAPI_UpdateStatusOfDevices_Call) RunAndReturn(run func(ctx context.Context, tenantId string, status string) client.ApiUpdateStatusOfDevicesRequest) *MockDeviceInventoryInternalAPIAPI_UpdateStatusOfDevices_Call {
	_c.Call.Return(run)
	return _c
}

// UpdateStatusOfDevicesExecute provides a mock function for the type MockDeviceInventoryInternalAPIAPI
func (_mock *MockDeviceInventoryInternalAPIAPI) UpdateStatusOfDevicesExecute(r client.ApiUpdateStatusOfDevicesRequest) (*http.Response, error) {
	ret := _mock.Called(r)

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

	var r0 *http.Response
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(client.ApiUpdateStatusOfDevicesRequest) (*http.Response, error)); ok {
		return returnFunc(r)
	}
	if returnFunc, ok := ret.Get(0).(func(client.ApiUpdateStatusOfDevicesRequest) *http.Response); ok {
		r0 = returnFunc(r)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*http.Response)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(client.ApiUpdateStatusOfDevicesRequest) error); ok {
		r1 = returnFunc(r)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// UpdateStatusOfDevicesExecute is a helper method to define mock.On call
//   - r client.ApiUpdateStatusOfDevicesRequest
func (_e *MockDeviceInventoryInternalAPIAPI_Expecter) UpdateStatusOfDevicesExecute(r interface{}) *MockDeviceInventoryInternalAPIAPI_UpdateStatusOfDevicesExecute_Call {
	return &MockDeviceInventoryInternalAPIAPI_UpdateStatusOfDevicesExecute_Call{Call: _e.mock.On("UpdateStatusOfDevicesExecute", r)}
}

func (_c *MockDeviceInventoryInternalAPIAPI_UpdateStatusOfDevicesExecute_Call) Run(run func(r client.ApiUpdateStatusOfDevicesRequest)) *MockDeviceInventoryInternalAPIAPI_UpdateStatusOfDevicesExecute_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 client.ApiUpdateStatusOfDevicesRequest
		if args[0] != nil {
			arg0 = args[0].(client.ApiUpdateStatusOfDevicesRequest)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *MockDeviceInventoryInternalAPIAPI_UpdateStatusOfDevicesExecute_Call) Return(response *http.Response, err error) *MockDeviceInventoryInternalAPIAPI_UpdateStatusOfDevicesExecute_Call {
	_c.Call.Return(response, err)
	return _c
}

func (_c *MockDeviceInventoryInternalAPIAPI_UpdateStatusOfDevicesExecute_Call) RunAndReturn(run func(r client.ApiUpdateStatusOfDevicesRequest) (*http.Response, error)) *MockDeviceInventoryInternalAPIAPI_UpdateStatusOfDevicesExecute_Call {
	_c.Call.Return(run)
	return _c
}

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

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

	return mock
}

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

type MockDeviceInventoryManagementAPIAPI_Expecter struct {
	mock *mock.Mock
}

func (_m *MockDeviceInventoryManagementAPIAPI) EXPECT() *MockDeviceInventoryManagementAPIAPI_Expecter {
	return &MockDeviceInventoryManagementAPIAPI_Expecter{mock: &_m.Mock}
}

// AddDevicesToGroup provides a mock function for the type MockDeviceInventoryManagementAPIAPI
func (_mock *MockDeviceInventoryManagementAPIAPI) AddDevicesToGroup(ctx context.Context, name string) client.ApiAddDevicesToGroupRequest {
	ret := _mock.Called(ctx, name)

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

	var r0 client.ApiAddDevicesToGroupRequest
	if returnFunc, ok := ret.Get(0).(func(context.Context, string) client.ApiAddDevicesToGroupRequest); ok {
		r0 = returnFunc(ctx, name)
	} else {
		r0 = ret.Get(0).(client.ApiAddDevicesToGroupRequest)
	}
	return r0
}

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

// AddDevicesToGroup is a helper method to define mock.On call
//   - ctx context.Context
//   - name string
func (_e *MockDeviceInventoryManagementAPIAPI_Expecter) AddDevicesToGroup(ctx interface{}, name interface{}) *MockDeviceInventoryManagementAPIAPI_AddDevicesToGroup_Call {
	return &MockDeviceInventoryManagementAPIAPI_AddDevicesToGroup_Call{Call: _e.mock.On("AddDevicesToGroup", ctx, name)}
}

func (_c *MockDeviceInventoryManagementAPIAPI_AddDevicesToGroup_Call) Run(run func(ctx context.Context, name string)) *MockDeviceInventoryManagementAPIAPI_AddDevicesToGroup_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 *MockDeviceInventoryManagementAPIAPI_AddDevicesToGroup_Call) Return(apiAddDevicesToGroupRequest client.ApiAddDevicesToGroupRequest) *MockDeviceInventoryManagementAPIAPI_AddDevicesToGroup_Call {
	_c.Call.Return(apiAddDevicesToGroupRequest)
	return _c
}

func (_c *MockDeviceInventoryManagementAPIAPI_AddDevicesToGroup_Call) RunAndReturn(run func(ctx context.Context, name string) client.ApiAddDevicesToGroupRequest) *MockDeviceInventoryManagementAPIAPI_AddDevicesToGroup_Call {
	_c.Call.Return(run)
	return _c
}

// AddDevicesToGroupExecute provides a mock function for the type MockDeviceInventoryManagementAPIAPI
func (_mock *MockDeviceInventoryManagementAPIAPI) AddDevicesToGroupExecute(r client.ApiAddDevicesToGroupRequest) (*client.AddDevicesToGroup200Response, *http.Response, error) {
	ret := _mock.Called(r)

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

	var r0 *client.AddDevicesToGroup200Response
	var r1 *http.Response
	var r2 error
	if returnFunc, ok := ret.Get(0).(func(client.ApiAddDevicesToGroupRequest) (*client.AddDevicesToGroup200Response, *http.Response, error)); ok {
		return returnFunc(r)
	}
	if returnFunc, ok := ret.Get(0).(func(client.ApiAddDevicesToGroupRequest) *client.AddDevicesToGroup200Response); ok {
		r0 = returnFunc(r)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*client.AddDevicesToGroup200Response)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(client.ApiAddDevicesToGroupRequest) *http.Response); ok {
		r1 = returnFunc(r)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*http.Response)
		}
	}
	if returnFunc, ok := ret.Get(2).(func(client.ApiAddDevicesToGroupRequest) error); ok {
		r2 = returnFunc(r)
	} else {
		r2 = ret.Error(2)
	}
	return r0, r1, r2
}

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

// AddDevicesToGroupExecute is a helper method to define mock.On call
//   - r client.ApiAddDevicesToGroupRequest
func (_e *MockDeviceInventoryManagementAPIAPI_Expecter) AddDevicesToGroupExecute(r interface{}) *MockDeviceInventoryManagementAPIAPI_AddDevicesToGroupExecute_Call {
	return &MockDeviceInventoryManagementAPIAPI_AddDevicesToGroupExecute_Call{Call: _e.mock.On("AddDevicesToGroupExecute", r)}
}

func (_c *MockDeviceInventoryManagementAPIAPI_AddDevicesToGroupExecute_Call) Run(run func(r client.ApiAddDevicesToGroupRequest)) *MockDeviceInventoryManagementAPIAPI_AddDevicesToGroupExecute_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 client.ApiAddDevicesToGroupRequest
		if args[0] != nil {
			arg0 = args[0].(client.ApiAddDevicesToGroupRequest)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *MockDeviceInventoryManagementAPIAPI_AddDevicesToGroupExecute_Call) Return(addDevicesToGroup200Response *client.AddDevicesToGroup200Response, response *http.Response, err error) *MockDeviceInventoryManagementAPIAPI_AddDevicesToGroupExecute_Call {
	_c.Call.Return(addDevicesToGroup200Response, response, err)
	return _c
}

func (_c *MockDeviceInventoryManagementAPIAPI_AddDevicesToGroupExecute_Call) RunAndReturn(run func(r client.ApiAddDevicesToGroupRequest) (*client.AddDevicesToGroup200Response, *http.Response, error)) *MockDeviceInventoryManagementAPIAPI_AddDevicesToGroupExecute_Call {
	_c.Call.Return(run)
	return _c
}

// AddTags provides a mock function for the type MockDeviceInventoryManagementAPIAPI
func (_mock *MockDeviceInventoryManagementAPIAPI) AddTags(ctx context.Context, id string) client.ApiAddTagsRequest {
	ret := _mock.Called(ctx, id)

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

	var r0 client.ApiAddTagsRequest
	if returnFunc, ok := ret.Get(0).(func(context.Context, string) client.ApiAddTagsRequest); ok {
		r0 = returnFunc(ctx, id)
	} else {
		r0 = ret.Get(0).(client.ApiAddTagsRequest)
	}
	return r0
}

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

// AddTags is a helper method to define mock.On call
//   - ctx context.Context
//   - id string
func (_e *MockDeviceInventoryManagementAPIAPI_Expecter) AddTags(ctx interface{}, id interface{}) *MockDeviceInventoryManagementAPIAPI_AddTags_Call {
	return &MockDeviceInventoryManagementAPIAPI_AddTags_Call{Call: _e.mock.On("AddTags", ctx, id)}
}

func (_c *MockDeviceInventoryManagementAPIAPI_AddTags_Call) Run(run func(ctx context.Context, id string)) *MockDeviceInventoryManagementAPIAPI_AddTags_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 *MockDeviceInventoryManagementAPIAPI_AddTags_Call) Return(apiAddTagsRequest client.ApiAddTagsRequest) *MockDeviceInventoryManagementAPIAPI_AddTags_Call {
	_c.Call.Return(apiAddTagsRequest)
	return _c
}

func (_c *MockDeviceInventoryManagementAPIAPI_AddTags_Call) RunAndReturn(run func(ctx context.Context, id string) client.ApiAddTagsRequest) *MockDeviceInventoryManagementAPIAPI_AddTags_Call {
	_c.Call.Return(run)
	return _c
}

// AddTagsExecute provides a mock function for the type MockDeviceInventoryManagementAPIAPI
func (_mock *MockDeviceInventoryManagementAPIAPI) AddTagsExecute(r client.ApiAddTagsRequest) (*http.Response, error) {
	ret := _mock.Called(r)

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

	var r0 *http.Response
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(client.ApiAddTagsRequest) (*http.Response, error)); ok {
		return returnFunc(r)
	}
	if returnFunc, ok := ret.Get(0).(func(client.ApiAddTagsRequest) *http.Response); ok {
		r0 = returnFunc(r)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*http.Response)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(client.ApiAddTagsRequest) error); ok {
		r1 = returnFunc(r)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// AddTagsExecute is a helper method to define mock.On call
//   - r client.ApiAddTagsRequest
func (_e *MockDeviceInventoryManagementAPIAPI_Expecter) AddTagsExecute(r interface{}) *MockDeviceInventoryManagementAPIAPI_AddTagsExecute_Call {
	return &MockDeviceInventoryManagementAPIAPI_AddTagsExecute_Call{Call: _e.mock.On("AddTagsExecute", r)}
}

func (_c *MockDeviceInventoryManagementAPIAPI_AddTagsExecute_Call) Run(run func(r client.ApiAddTagsRequest)) *MockDeviceInventoryManagementAPIAPI_AddTagsExecute_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 client.ApiAddTagsRequest
		if args[0] != nil {
			arg0 = args[0].(client.ApiAddTagsRequest)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *MockDeviceInventoryManagementAPIAPI_AddTagsExecute_Call) Return(response *http.Response, err error) *MockDeviceInventoryManagementAPIAPI_AddTagsExecute_Call {
	_c.Call.Return(response, err)
	return _c
}

func (_c *MockDeviceInventoryManagementAPIAPI_AddTagsExecute_Call) RunAndReturn(run func(r client.ApiAddTagsRequest) (*http.Response, error)) *MockDeviceInventoryManagementAPIAPI_AddTagsExecute_Call {
	_c.Call.Return(run)
	return _c
}

// AssignGroup provides a mock function for the type MockDeviceInventoryManagementAPIAPI
func (_mock *MockDeviceInventoryManagementAPIAPI) AssignGroup(ctx context.Context, id string) client.ApiAssignGroupRequest {
	ret := _mock.Called(ctx, id)

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

	var r0 client.ApiAssignGroupRequest
	if returnFunc, ok := ret.Get(0).(func(context.Context, string) client.ApiAssignGroupRequest); ok {
		r0 = returnFunc(ctx, id)
	} else {
		r0 = ret.Get(0).(client.ApiAssignGroupRequest)
	}
	return r0
}

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

// AssignGroup is a helper method to define mock.On call
//   - ctx context.Context
//   - id string
func (_e *MockDeviceInventoryManagementAPIAPI_Expecter) AssignGroup(ctx interface{}, id interface{}) *MockDeviceInventoryManagementAPIAPI_AssignGroup_Call {
	return &MockDeviceInventoryManagementAPIAPI_AssignGroup_Call{Call: _e.mock.On("AssignGroup", ctx, id)}
}

func (_c *MockDeviceInventoryManagementAPIAPI_AssignGroup_Call) Run(run func(ctx context.Context, id string)) *MockDeviceInventoryManagementAPIAPI_AssignGroup_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 *MockDeviceInventoryManagementAPIAPI_AssignGroup_Call) Return(apiAssignGroupRequest client.ApiAssignGroupRequest) *MockDeviceInventoryManagementAPIAPI_AssignGroup_Call {
	_c.Call.Return(apiAssignGroupRequest)
	return _c
}

func (_c *MockDeviceInventoryManagementAPIAPI_AssignGroup_Call) RunAndReturn(run func(ctx context.Context, id string) client.ApiAssignGroupRequest) *MockDeviceInventoryManagementAPIAPI_AssignGroup_Call {
	_c.Call.Return(run)
	return _c
}

// AssignGroupExecute provides a mock function for the type MockDeviceInventoryManagementAPIAPI
func (_mock *MockDeviceInventoryManagementAPIAPI) AssignGroupExecute(r client.ApiAssignGroupRequest) (*http.Response, error) {
	ret := _mock.Called(r)

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

	var r0 *http.Response
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(client.ApiAssignGroupRequest) (*http.Response, error)); ok {
		return returnFunc(r)
	}
	if returnFunc, ok := ret.Get(0).(func(client.ApiAssignGroupRequest) *http.Response); ok {
		r0 = returnFunc(r)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*http.Response)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(client.ApiAssignGroupRequest) error); ok {
		r1 = returnFunc(r)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// AssignGroupExecute is a helper method to define mock.On call
//   - r client.ApiAssignGroupRequest
func (_e *MockDeviceInventoryManagementAPIAPI_Expecter) AssignGroupExecute(r interface{}) *MockDeviceInventoryManagementAPIAPI_AssignGroupExecute_Call {
	return &MockDeviceInventoryManagementAPIAPI_AssignGroupExecute_Call{Call: _e.mock.On("AssignGroupExecute", r)}
}

func (_c *MockDeviceInventoryManagementAPIAPI_AssignGroupExecute_Call) Run(run func(r client.ApiAssignGroupRequest)) *MockDeviceInventoryManagementAPIAPI_AssignGroupExecute_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 client.ApiAssignGroupRequest
		if args[0] != nil {
			arg0 = args[0].(client.ApiAssignGroupRequest)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *MockDeviceInventoryManagementAPIAPI_AssignGroupExecute_Call) Return(response *http.Response, err error) *MockDeviceInventoryManagementAPIAPI_AssignGroupExecute_Call {
	_c.Call.Return(response, err)
	return _c
}

func (_c *MockDeviceInventoryManagementAPIAPI_AssignGroupExecute_Call) RunAndReturn(run func(r client.ApiAssignGroupRequest) (*http.Response, error)) *MockDeviceInventoryManagementAPIAPI_AssignGroupExecute_Call {
	_c.Call.Return(run)
	return _c
}

// AssignTags provides a mock function for the type MockDeviceInventoryManagementAPIAPI
func (_mock *MockDeviceInventoryManagementAPIAPI) AssignTags(ctx context.Context, id string) client.ApiAssignTagsRequest {
	ret := _mock.Called(ctx, id)

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

	var r0 client.ApiAssignTagsRequest
	if returnFunc, ok := ret.Get(0).(func(context.Context, string) client.ApiAssignTagsRequest); ok {
		r0 = returnFunc(ctx, id)
	} else {
		r0 = ret.Get(0).(client.ApiAssignTagsRequest)
	}
	return r0
}

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

// AssignTags is a helper method to define mock.On call
//   - ctx context.Context
//   - id string
func (_e *MockDeviceInventoryManagementAPIAPI_Expecter) AssignTags(ctx interface{}, id interface{}) *MockDeviceInventoryManagementAPIAPI_AssignTags_Call {
	return &MockDeviceInventoryManagementAPIAPI_AssignTags_Call{Call: _e.mock.On("AssignTags", ctx, id)}
}

func (_c *MockDeviceInventoryManagementAPIAPI_AssignTags_Call) Run(run func(ctx context.Context, id string)) *MockDeviceInventoryManagementAPIAPI_AssignTags_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 *MockDeviceInventoryManagementAPIAPI_AssignTags_Call) Return(apiAssignTagsRequest client.ApiAssignTagsRequest) *MockDeviceInventoryManagementAPIAPI_AssignTags_Call {
	_c.Call.Return(apiAssignTagsRequest)
	return _c
}

func (_c *MockDeviceInventoryManagementAPIAPI_AssignTags_Call) RunAndReturn(run func(ctx context.Context, id string) client.ApiAssignTagsRequest) *MockDeviceInventoryManagementAPIAPI_AssignTags_Call {
	_c.Call.Return(run)
	return _c
}

// AssignTagsExecute provides a mock function for the type MockDeviceInventoryManagementAPIAPI
func (_mock *MockDeviceInventoryManagementAPIAPI) AssignTagsExecute(r client.ApiAssignTagsRequest) (*http.Response, error) {
	ret := _mock.Called(r)

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

	var r0 *http.Response
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(client.ApiAssignTagsRequest) (*http.Response, error)); ok {
		return returnFunc(r)
	}
	if returnFunc, ok := ret.Get(0).(func(client.ApiAssignTagsRequest) *http.Response); ok {
		r0 = returnFunc(r)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*http.Response)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(client.ApiAssignTagsRequest) error); ok {
		r1 = returnFunc(r)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// AssignTagsExecute is a helper method to define mock.On call
//   - r client.ApiAssignTagsRequest
func (_e *MockDeviceInventoryManagementAPIAPI_Expecter) AssignTagsExecute(r interface{}) *MockDeviceInventoryManagementAPIAPI_AssignTagsExecute_Call {
	return &MockDeviceInventoryManagementAPIAPI_AssignTagsExecute_Call{Call: _e.mock.On("AssignTagsExecute", r)}
}

func (_c *MockDeviceInventoryManagementAPIAPI_AssignTagsExecute_Call) Run(run func(r client.ApiAssignTagsRequest)) *MockDeviceInventoryManagementAPIAPI_AssignTagsExecute_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 client.ApiAssignTagsRequest
		if args[0] != nil {
			arg0 = args[0].(client.ApiAssignTagsRequest)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *MockDeviceInventoryManagementAPIAPI_AssignTagsExecute_Call) Return(response *http.Response, err error) *MockDeviceInventoryManagementAPIAPI_AssignTagsExecute_Call {
	_c.Call.Return(response, err)
	return _c
}

func (_c *MockDeviceInventoryManagementAPIAPI_AssignTagsExecute_Call) RunAndReturn(run func(r client.ApiAssignTagsRequest) (*http.Response, error)) *MockDeviceInventoryManagementAPIAPI_AssignTagsExecute_Call {
	_c.Call.Return(run)
	return _c
}

// ClearGroup provides a mock function for the type MockDeviceInventoryManagementAPIAPI
func (_mock *MockDeviceInventoryManagementAPIAPI) ClearGroup(ctx context.Context, id string, name string) client.ApiClearGroupRequest {
	ret := _mock.Called(ctx, id, name)

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

	var r0 client.ApiClearGroupRequest
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string) client.ApiClearGroupRequest); ok {
		r0 = returnFunc(ctx, id, name)
	} else {
		r0 = ret.Get(0).(client.ApiClearGroupRequest)
	}
	return r0
}

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

// ClearGroup is a helper method to define mock.On call
//   - ctx context.Context
//   - id string
//   - name string
func (_e *MockDeviceInventoryManagementAPIAPI_Expecter) ClearGroup(ctx interface{}, id interface{}, name interface{}) *MockDeviceInventoryManagementAPIAPI_ClearGroup_Call {
	return &MockDeviceInventoryManagementAPIAPI_ClearGroup_Call{Call: _e.mock.On("ClearGroup", ctx, id, name)}
}

func (_c *MockDeviceInventoryManagementAPIAPI_ClearGroup_Call) Run(run func(ctx context.Context, id string, name string)) *MockDeviceInventoryManagementAPIAPI_ClearGroup_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)
		}
		run(
			arg0,
			arg1,
			arg2,
		)
	})
	return _c
}

func (_c *MockDeviceInventoryManagementAPIAPI_ClearGroup_Call) Return(apiClearGroupRequest client.ApiClearGroupRequest) *MockDeviceInventoryManagementAPIAPI_ClearGroup_Call {
	_c.Call.Return(apiClearGroupRequest)
	return _c
}

func (_c *MockDeviceInventoryManagementAPIAPI_ClearGroup_Call) RunAndReturn(run func(ctx context.Context, id string, name string) client.ApiClearGroupRequest) *MockDeviceInventoryManagementAPIAPI_ClearGroup_Call {
	_c.Call.Return(run)
	return _c
}

// ClearGroupExecute provides a mock function for the type MockDeviceInventoryManagementAPIAPI
func (_mock *MockDeviceInventoryManagementAPIAPI) ClearGroupExecute(r client.ApiClearGroupRequest) (*http.Response, error) {
	ret := _mock.Called(r)

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

	var r0 *http.Response
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(client.ApiClearGroupRequest) (*http.Response, error)); ok {
		return returnFunc(r)
	}
	if returnFunc, ok := ret.Get(0).(func(client.ApiClearGroupRequest) *http.Response); ok {
		r0 = returnFunc(r)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*http.Response)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(client.ApiClearGroupRequest) error); ok {
		r1 = returnFunc(r)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// ClearGroupExecute is a helper method to define mock.On call
//   - r client.ApiClearGroupRequest
func (_e *MockDeviceInventoryManagementAPIAPI_Expecter) ClearGroupExecute(r interface{}) *MockDeviceInventoryManagementAPIAPI_ClearGroupExecute_Call {
	return &MockDeviceInventoryManagementAPIAPI_ClearGroupExecute_Call{Call: _e.mock.On("ClearGroupExecute", r)}
}

func (_c *MockDeviceInventoryManagementAPIAPI_ClearGroupExecute_Call) Run(run func(r client.ApiClearGroupRequest)) *MockDeviceInventoryManagementAPIAPI_ClearGroupExecute_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 client.ApiClearGroupRequest
		if args[0] != nil {
			arg0 = args[0].(client.ApiClearGroupRequest)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *MockDeviceInventoryManagementAPIAPI_ClearGroupExecute_Call) Return(response *http.Response, err error) *MockDeviceInventoryManagementAPIAPI_ClearGroupExecute_Call {
	_c.Call.Return(response, err)
	return _c
}

func (_c *MockDeviceInventoryManagementAPIAPI_ClearGroupExecute_Call) RunAndReturn(run func(r client.ApiClearGroupRequest) (*http.Response, error)) *MockDeviceInventoryManagementAPIAPI_ClearGroupExecute_Call {
	_c.Call.Return(run)
	return _c
}

// DeleteDeviceInventory provides a mock function for the type MockDeviceInventoryManagementAPIAPI
func (_mock *MockDeviceInventoryManagementAPIAPI) DeleteDeviceInventory(ctx context.Context, id string) client.ApiDeleteDeviceInventoryRequest {
	ret := _mock.Called(ctx, id)

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

	var r0 client.ApiDeleteDeviceInventoryRequest
	if returnFunc, ok := ret.Get(0).(func(context.Context, string) client.ApiDeleteDeviceInventoryRequest); ok {
		r0 = returnFunc(ctx, id)
	} else {
		r0 = ret.Get(0).(client.ApiDeleteDeviceInventoryRequest)
	}
	return r0
}

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

// DeleteDeviceInventory is a helper method to define mock.On call
//   - ctx context.Context
//   - id string
func (_e *MockDeviceInventoryManagementAPIAPI_Expecter) DeleteDeviceInventory(ctx interface{}, id interface{}) *MockDeviceInventoryManagementAPIAPI_DeleteDeviceInventory_Call {
	return &MockDeviceInventoryManagementAPIAPI_DeleteDeviceInventory_Call{Call: _e.mock.On("DeleteDeviceInventory", ctx, id)}
}

func (_c *MockDeviceInventoryManagementAPIAPI_DeleteDeviceInventory_Call) Run(run func(ctx context.Context, id string)) *MockDeviceInventoryManagementAPIAPI_DeleteDeviceInventory_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 *MockDeviceInventoryManagementAPIAPI_DeleteDeviceInventory_Call) Return(apiDeleteDeviceInventoryRequest client.ApiDeleteDeviceInventoryRequest) *MockDeviceInventoryManagementAPIAPI_DeleteDeviceInventory_Call {
	_c.Call.Return(apiDeleteDeviceInventoryRequest)
	return _c
}

func (_c *MockDeviceInventoryManagementAPIAPI_DeleteDeviceInventory_Call) RunAndReturn(run func(ctx context.Context, id string) client.ApiDeleteDeviceInventoryRequest) *MockDeviceInventoryManagementAPIAPI_DeleteDeviceInventory_Call {
	_c.Call.Return(run)
	return _c
}

// DeleteDeviceInventoryExecute provides a mock function for the type MockDeviceInventoryManagementAPIAPI
func (_mock *MockDeviceInventoryManagementAPIAPI) DeleteDeviceInventoryExecute(r client.ApiDeleteDeviceInventoryRequest) (*http.Response, error) {
	ret := _mock.Called(r)

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

	var r0 *http.Response
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(client.ApiDeleteDeviceInventoryRequest) (*http.Response, error)); ok {
		return returnFunc(r)
	}
	if returnFunc, ok := ret.Get(0).(func(client.ApiDeleteDeviceInventoryRequest) *http.Response); ok {
		r0 = returnFunc(r)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*http.Response)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(client.ApiDeleteDeviceInventoryRequest) error); ok {
		r1 = returnFunc(r)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// DeleteDeviceInventoryExecute is a helper method to define mock.On call
//   - r client.ApiDeleteDeviceInventoryRequest
func (_e *MockDeviceInventoryManagementAPIAPI_Expecter) DeleteDeviceInventoryExecute(r interface{}) *MockDeviceInventoryManagementAPIAPI_DeleteDeviceInventoryExecute_Call {
	return &MockDeviceInventoryManagementAPIAPI_DeleteDeviceInventoryExecute_Call{Call: _e.mock.On("DeleteDeviceInventoryExecute", r)}
}

func (_c *MockDeviceInventoryManagementAPIAPI_DeleteDeviceInventoryExecute_Call) Run(run func(r client.ApiDeleteDeviceInventoryRequest)) *MockDeviceInventoryManagementAPIAPI_DeleteDeviceInventoryExecute_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 client.ApiDeleteDeviceInventoryRequest
		if args[0] != nil {
			arg0 = args[0].(client.ApiDeleteDeviceInventoryRequest)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *MockDeviceInventoryManagementAPIAPI_DeleteDeviceInventoryExecute_Call) Return(response *http.Response, err error) *MockDeviceInventoryManagementAPIAPI_DeleteDeviceInventoryExecute_Call {
	_c.Call.Return(response, err)
	return _c
}

func (_c *MockDeviceInventoryManagementAPIAPI_DeleteDeviceInventoryExecute_Call) RunAndReturn(run func(r client.ApiDeleteDeviceInventoryRequest) (*http.Response, error)) *MockDeviceInventoryManagementAPIAPI_DeleteDeviceInventoryExecute_Call {
	_c.Call.Return(run)
	return _c
}

// GetDeviceGroup provides a mock function for the type MockDeviceInventoryManagementAPIAPI
func (_mock *MockDeviceInventoryManagementAPIAPI) GetDeviceGroup(ctx context.Context, id string) client.ApiGetDeviceGroupRequest {
	ret := _mock.Called(ctx, id)

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

	var r0 client.ApiGetDeviceGroupRequest
	if returnFunc, ok := ret.Get(0).(func(context.Context, string) client.ApiGetDeviceGroupRequest); ok {
		r0 = returnFunc(ctx, id)
	} else {
		r0 = ret.Get(0).(client.ApiGetDeviceGroupRequest)
	}
	return r0
}

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

// GetDeviceGroup is a helper method to define mock.On call
//   - ctx context.Context
//   - id string
func (_e *MockDeviceInventoryManagementAPIAPI_Expecter) GetDeviceGroup(ctx interface{}, id interface{}) *MockDeviceInventoryManagementAPIAPI_GetDeviceGroup_Call {
	return &MockDeviceInventoryManagementAPIAPI_GetDeviceGroup_Call{Call: _e.mock.On("GetDeviceGroup", ctx, id)}
}

func (_c *MockDeviceInventoryManagementAPIAPI_GetDeviceGroup_Call) Run(run func(ctx context.Context, id string)) *MockDeviceInventoryManagementAPIAPI_GetDeviceGroup_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 *MockDeviceInventoryManagementAPIAPI_GetDeviceGroup_Call) Return(apiGetDeviceGroupRequest client.ApiGetDeviceGroupRequest) *MockDeviceInventoryManagementAPIAPI_GetDeviceGroup_Call {
	_c.Call.Return(apiGetDeviceGroupRequest)
	return _c
}

func (_c *MockDeviceInventoryManagementAPIAPI_GetDeviceGroup_Call) RunAndReturn(run func(ctx context.Context, id string) client.ApiGetDeviceGroupRequest) *MockDeviceInventoryManagementAPIAPI_GetDeviceGroup_Call {
	_c.Call.Return(run)
	return _c
}

// GetDeviceGroupExecute provides a mock function for the type MockDeviceInventoryManagementAPIAPI
func (_mock *MockDeviceInventoryManagementAPIAPI) GetDeviceGroupExecute(r client.ApiGetDeviceGroupRequest) (*client.Group, *http.Response, error) {
	ret := _mock.Called(r)

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

	var r0 *client.Group
	var r1 *http.Response
	var r2 error
	if returnFunc, ok := ret.Get(0).(func(client.ApiGetDeviceGroupRequest) (*client.Group, *http.Response, error)); ok {
		return returnFunc(r)
	}
	if returnFunc, ok := ret.Get(0).(func(client.ApiGetDeviceGroupRequest) *client.Group); ok {
		r0 = returnFunc(r)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*client.Group)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(client.ApiGetDeviceGroupRequest) *http.Response); ok {
		r1 = returnFunc(r)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*http.Response)
		}
	}
	if returnFunc, ok := ret.Get(2).(func(client.ApiGetDeviceGroupRequest) error); ok {
		r2 = returnFunc(r)
	} else {
		r2 = ret.Error(2)
	}
	return r0, r1, r2
}

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

// GetDeviceGroupExecute is a helper method to define mock.On call
//   - r client.ApiGetDeviceGroupRequest
func (_e *MockDeviceInventoryManagementAPIAPI_Expecter) GetDeviceGroupExecute(r interface{}) *MockDeviceInventoryManagementAPIAPI_GetDeviceGroupExecute_Call {
	return &MockDeviceInventoryManagementAPIAPI_GetDeviceGroupExecute_Call{Call: _e.mock.On("GetDeviceGroupExecute", r)}
}

func (_c *MockDeviceInventoryManagementAPIAPI_GetDeviceGroupExecute_Call) Run(run func(r client.ApiGetDeviceGroupRequest)) *MockDeviceInventoryManagementAPIAPI_GetDeviceGroupExecute_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 client.ApiGetDeviceGroupRequest
		if args[0] != nil {
			arg0 = args[0].(client.ApiGetDeviceGroupRequest)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *MockDeviceInventoryManagementAPIAPI_GetDeviceGroupExecute_Call) Return(group *client.Group, response *http.Response, err error) *MockDeviceInventoryManagementAPIAPI_GetDeviceGroupExecute_Call {
	_c.Call.Return(group, response, err)
	return _c
}

func (_c *MockDeviceInventoryManagementAPIAPI_GetDeviceGroupExecute_Call) RunAndReturn(run func(r client.ApiGetDeviceGroupRequest) (*client.Group, *http.Response, error)) *MockDeviceInventoryManagementAPIAPI_GetDeviceGroupExecute_Call {
	_c.Call.Return(run)
	return _c
}

// GetDeviceInventory provides a mock function for the type MockDeviceInventoryManagementAPIAPI
func (_mock *MockDeviceInventoryManagementAPIAPI) GetDeviceInventory(ctx context.Context, id string) client.ApiGetDeviceInventoryRequest {
	ret := _mock.Called(ctx, id)

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

	var r0 client.ApiGetDeviceInventoryRequest
	if returnFunc, ok := ret.Get(0).(func(context.Context, string) client.ApiGetDeviceInventoryRequest); ok {
		r0 = returnFunc(ctx, id)
	} else {
		r0 = ret.Get(0).(client.ApiGetDeviceInventoryRequest)
	}
	return r0
}

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

// GetDeviceInventory is a helper method to define mock.On call
//   - ctx context.Context
//   - id string
func (_e *MockDeviceInventoryManagementAPIAPI_Expecter) GetDeviceInventory(ctx interface{}, id interface{}) *MockDeviceInventoryManagementAPIAPI_GetDeviceInventory_Call {
	return &MockDeviceInventoryManagementAPIAPI_GetDeviceInventory_Call{Call: _e.mock.On("GetDeviceInventory", ctx, id)}
}

func (_c *MockDeviceInventoryManagementAPIAPI_GetDeviceInventory_Call) Run(run func(ctx context.Context, id string)) *MockDeviceInventoryManagementAPIAPI_GetDeviceInventory_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 *MockDeviceInventoryManagementAPIAPI_GetDeviceInventory_Call) Return(apiGetDeviceInventoryRequest client.ApiGetDeviceInventoryRequest) *MockDeviceInventoryManagementAPIAPI_GetDeviceInventory_Call {
	_c.Call.Return(apiGetDeviceInventoryRequest)
	return _c
}

func (_c *MockDeviceInventoryManagementAPIAPI_GetDeviceInventory_Call) RunAndReturn(run func(ctx context.Context, id string) client.ApiGetDeviceInventoryRequest) *MockDeviceInventoryManagementAPIAPI_GetDeviceInventory_Call {
	_c.Call.Return(run)
	return _c
}

// GetDeviceInventoryExecute provides a mock function for the type MockDeviceInventoryManagementAPIAPI
func (_mock *MockDeviceInventoryManagementAPIAPI) GetDeviceInventoryExecute(r client.ApiGetDeviceInventoryRequest) (*client.DeviceInventoryResponse, *http.Response, error) {
	ret := _mock.Called(r)

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

	var r0 *client.DeviceInventoryResponse
	var r1 *http.Response
	var r2 error
	if returnFunc, ok := ret.Get(0).(func(client.ApiGetDeviceInventoryRequest) (*client.DeviceInventoryResponse, *http.Response, error)); ok {
		return returnFunc(r)
	}
	if returnFunc, ok := ret.Get(0).(func(client.ApiGetDeviceInventoryRequest) *client.DeviceInventoryResponse); ok {
		r0 = returnFunc(r)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*client.DeviceInventoryResponse)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(client.ApiGetDeviceInventoryRequest) *http.Response); ok {
		r1 = returnFunc(r)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*http.Response)
		}
	}
	if returnFunc, ok := ret.Get(2).(func(client.ApiGetDeviceInventoryRequest) error); ok {
		r2 = returnFunc(r)
	} else {
		r2 = ret.Error(2)
	}
	return r0, r1, r2
}

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

// GetDeviceInventoryExecute is a helper method to define mock.On call
//   - r client.ApiGetDeviceInventoryRequest
func (_e *MockDeviceInventoryManagementAPIAPI_Expecter) GetDeviceInventoryExecute(r interface{}) *MockDeviceInventoryManagementAPIAPI_GetDeviceInventoryExecute_Call {
	return &MockDeviceInventoryManagementAPIAPI_GetDeviceInventoryExecute_Call{Call: _e.mock.On("GetDeviceInventoryExecute", r)}
}

func (_c *MockDeviceInventoryManagementAPIAPI_GetDeviceInventoryExecute_Call) Run(run func(r client.ApiGetDeviceInventoryRequest)) *MockDeviceInventoryManagementAPIAPI_GetDeviceInventoryExecute_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 client.ApiGetDeviceInventoryRequest
		if args[0] != nil {
			arg0 = args[0].(client.ApiGetDeviceInventoryRequest)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *MockDeviceInventoryManagementAPIAPI_GetDeviceInventoryExecute_Call) Return(deviceInventoryResponse *client.DeviceInventoryResponse, response *http.Response, err error) *MockDeviceInventoryManagementAPIAPI_GetDeviceInventoryExecute_Call {
	_c.Call.Return(deviceInventoryResponse, response, err)
	return _c
}

func (_c *MockDeviceInventoryManagementAPIAPI_GetDeviceInventoryExecute_Call) RunAndReturn(run func(r client.ApiGetDeviceInventoryRequest) (*client.DeviceInventoryResponse, *http.Response, error)) *MockDeviceInventoryManagementAPIAPI_GetDeviceInventoryExecute_Call {
	_c.Call.Return(run)
	return _c
}

// GetDevicesInGroup provides a mock function for the type MockDeviceInventoryManagementAPIAPI
func (_mock *MockDeviceInventoryManagementAPIAPI) GetDevicesInGroup(ctx context.Context, name string) client.ApiGetDevicesInGroupRequest {
	ret := _mock.Called(ctx, name)

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

	var r0 client.ApiGetDevicesInGroupRequest
	if returnFunc, ok := ret.Get(0).(func(context.Context, string) client.ApiGetDevicesInGroupRequest); ok {
		r0 = returnFunc(ctx, name)
	} else {
		r0 = ret.Get(0).(client.ApiGetDevicesInGroupRequest)
	}
	return r0
}

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

// GetDevicesInGroup is a helper method to define mock.On call
//   - ctx context.Context
//   - name string
func (_e *MockDeviceInventoryManagementAPIAPI_Expecter) GetDevicesInGroup(ctx interface{}, name interface{}) *MockDeviceInventoryManagementAPIAPI_GetDevicesInGroup_Call {
	return &MockDeviceInventoryManagementAPIAPI_GetDevicesInGroup_Call{Call: _e.mock.On("GetDevicesInGroup", ctx, name)}
}

func (_c *MockDeviceInventoryManagementAPIAPI_GetDevicesInGroup_Call) Run(run func(ctx context.Context, name string)) *MockDeviceInventoryManagementAPIAPI_GetDevicesInGroup_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 *MockDeviceInventoryManagementAPIAPI_GetDevicesInGroup_Call) Return(apiGetDevicesInGroupRequest client.ApiGetDevicesInGroupRequest) *MockDeviceInventoryManagementAPIAPI_GetDevicesInGroup_Call {
	_c.Call.Return(apiGetDevicesInGroupRequest)
	return _c
}

func (_c *MockDeviceInventoryManagementAPIAPI_GetDevicesInGroup_Call) RunAndReturn(run func(ctx context.Context, name string) client.ApiGetDevicesInGroupRequest) *MockDeviceInventoryManagementAPIAPI_GetDevicesInGroup_Call {
	_c.Call.Return(run)
	return _c
}

// GetDevicesInGroupExecute provides a mock function for the type MockDeviceInventoryManagementAPIAPI
func (_mock *MockDeviceInventoryManagementAPIAPI) GetDevicesInGroupExecute(r client.ApiGetDevicesInGroupRequest) ([]string, *http.Response, error) {
	ret := _mock.Called(r)

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

	var r0 []string
	var r1 *http.Response
	var r2 error
	if returnFunc, ok := ret.Get(0).(func(client.ApiGetDevicesInGroupRequest) ([]string, *http.Response, error)); ok {
		return returnFunc(r)
	}
	if returnFunc, ok := ret.Get(0).(func(client.ApiGetDevicesInGroupRequest) []string); ok {
		r0 = returnFunc(r)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]string)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(client.ApiGetDevicesInGroupRequest) *http.Response); ok {
		r1 = returnFunc(r)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*http.Response)
		}
	}
	if returnFunc, ok := ret.Get(2).(func(client.ApiGetDevicesInGroupRequest) error); ok {
		r2 = returnFunc(r)
	} else {
		r2 = ret.Error(2)
	}
	return r0, r1, r2
}

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

// GetDevicesInGroupExecute is a helper method to define mock.On call
//   - r client.ApiGetDevicesInGroupRequest
func (_e *MockDeviceInventoryManagementAPIAPI_Expecter) GetDevicesInGroupExecute(r interface{}) *MockDeviceInventoryManagementAPIAPI_GetDevicesInGroupExecute_Call {
	return &MockDeviceInventoryManagementAPIAPI_GetDevicesInGroupExecute_Call{Call: _e.mock.On("GetDevicesInGroupExecute", r)}
}

func (_c *MockDeviceInventoryManagementAPIAPI_GetDevicesInGroupExecute_Call) Run(run func(r client.ApiGetDevicesInGroupRequest)) *MockDeviceInventoryManagementAPIAPI_GetDevicesInGroupExecute_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 client.ApiGetDevicesInGroupRequest
		if args[0] != nil {
			arg0 = args[0].(client.ApiGetDevicesInGroupRequest)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *MockDeviceInventoryManagementAPIAPI_GetDevicesInGroupExecute_Call) Return(strings []string, response *http.Response, err error) *MockDeviceInventoryManagementAPIAPI_GetDevicesInGroupExecute_Call {
	_c.Call.Return(strings, response, err)
	return _c
}

func (_c *MockDeviceInventoryManagementAPIAPI_GetDevicesInGroupExecute_Call) RunAndReturn(run func(r client.ApiGetDevicesInGroupRequest) ([]string, *http.Response, error)) *MockDeviceInventoryManagementAPIAPI_GetDevicesInGroupExecute_Call {
	_c.Call.Return(run)
	return _c
}

// ListDeviceInventories provides a mock function for the type MockDeviceInventoryManagementAPIAPI
func (_mock *MockDeviceInventoryManagementAPIAPI) ListDeviceInventories(ctx context.Context) client.ApiListDeviceInventoriesRequest {
	ret := _mock.Called(ctx)

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

	var r0 client.ApiListDeviceInventoriesRequest
	if returnFunc, ok := ret.Get(0).(func(context.Context) client.ApiListDeviceInventoriesRequest); ok {
		r0 = returnFunc(ctx)
	} else {
		r0 = ret.Get(0).(client.ApiListDeviceInventoriesRequest)
	}
	return r0
}

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

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

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

func (_c *MockDeviceInventoryManagementAPIAPI_ListDeviceInventories_Call) Return(apiListDeviceInventoriesRequest client.ApiListDeviceInventoriesRequest) *MockDeviceInventoryManagementAPIAPI_ListDeviceInventories_Call {
	_c.Call.Return(apiListDeviceInventoriesRequest)
	return _c
}

func (_c *MockDeviceInventoryManagementAPIAPI_ListDeviceInventories_Call) RunAndReturn(run func(ctx context.Context) client.ApiListDeviceInventoriesRequest) *MockDeviceInventoryManagementAPIAPI_ListDeviceInventories_Call {
	_c.Call.Return(run)
	return _c
}

// ListDeviceInventoriesExecute provides a mock function for the type MockDeviceInventoryManagementAPIAPI
func (_mock *MockDeviceInventoryManagementAPIAPI) ListDeviceInventoriesExecute(r client.ApiListDeviceInventoriesRequest) ([]client.DeviceInventoryResponse, *http.Response, error) {
	ret := _mock.Called(r)

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

	var r0 []client.DeviceInventoryResponse
	var r1 *http.Response
	var r2 error
	if returnFunc, ok := ret.Get(0).(func(client.ApiListDeviceInventoriesRequest) ([]client.DeviceInventoryResponse, *http.Response, error)); ok {
		return returnFunc(r)
	}
	if returnFunc, ok := ret.Get(0).(func(client.ApiListDeviceInventoriesRequest) []client.DeviceInventoryResponse); ok {
		r0 = returnFunc(r)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]client.DeviceInventoryResponse)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(client.ApiListDeviceInventoriesRequest) *http.Response); ok {
		r1 = returnFunc(r)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*http.Response)
		}
	}
	if returnFunc, ok := ret.Get(2).(func(client.ApiListDeviceInventoriesRequest) error); ok {
		r2 = returnFunc(r)
	} else {
		r2 = ret.Error(2)
	}
	return r0, r1, r2
}

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

// ListDeviceInventoriesExecute is a helper method to define mock.On call
//   - r client.ApiListDeviceInventoriesRequest
func (_e *MockDeviceInventoryManagementAPIAPI_Expecter) ListDeviceInventoriesExecute(r interface{}) *MockDeviceInventoryManagementAPIAPI_ListDeviceInventoriesExecute_Call {
	return &MockDeviceInventoryManagementAPIAPI_ListDeviceInventoriesExecute_Call{Call: _e.mock.On("ListDeviceInventoriesExecute", r)}
}

func (_c *MockDeviceInventoryManagementAPIAPI_ListDeviceInventoriesExecute_Call) Run(run func(r client.ApiListDeviceInventoriesRequest)) *MockDeviceInventoryManagementAPIAPI_ListDeviceInventoriesExecute_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 client.ApiListDeviceInventoriesRequest
		if args[0] != nil {
			arg0 = args[0].(client.ApiListDeviceInventoriesRequest)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *MockDeviceInventoryManagementAPIAPI_ListDeviceInventoriesExecute_Call) Return(deviceInventoryResponses []client.DeviceInventoryResponse, response *http.Response, err error) *MockDeviceInventoryManagementAPIAPI_ListDeviceInventoriesExecute_Call {
	_c.Call.Return(deviceInventoryResponses, response, err)
	return _c
}

func (_c *MockDeviceInventoryManagementAPIAPI_ListDeviceInventoriesExecute_Call) RunAndReturn(run func(r client.ApiListDeviceInventoriesRequest) ([]client.DeviceInventoryResponse, *http.Response, error)) *MockDeviceInventoryManagementAPIAPI_ListDeviceInventoriesExecute_Call {
	_c.Call.Return(run)
	return _c
}

// ListGroups provides a mock function for the type MockDeviceInventoryManagementAPIAPI
func (_mock *MockDeviceInventoryManagementAPIAPI) ListGroups(ctx context.Context) client.ApiListGroupsRequest {
	ret := _mock.Called(ctx)

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

	var r0 client.ApiListGroupsRequest
	if returnFunc, ok := ret.Get(0).(func(context.Context) client.ApiListGroupsRequest); ok {
		r0 = returnFunc(ctx)
	} else {
		r0 = ret.Get(0).(client.ApiListGroupsRequest)
	}
	return r0
}

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

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

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

func (_c *MockDeviceInventoryManagementAPIAPI_ListGroups_Call) Return(apiListGroupsRequest client.ApiListGroupsRequest) *MockDeviceInventoryManagementAPIAPI_ListGroups_Call {
	_c.Call.Return(apiListGroupsRequest)
	return _c
}

func (_c *MockDeviceInventoryManagementAPIAPI_ListGroups_Call) RunAndReturn(run func(ctx context.Context) client.ApiListGroupsRequest) *MockDeviceInventoryManagementAPIAPI_ListGroups_Call {
	_c.Call.Return(run)
	return _c
}

// ListGroupsExecute provides a mock function for the type MockDeviceInventoryManagementAPIAPI
func (_mock *MockDeviceInventoryManagementAPIAPI) ListGroupsExecute(r client.ApiListGroupsRequest) ([]string, *http.Response, error) {
	ret := _mock.Called(r)

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

	var r0 []string
	var r1 *http.Response
	var r2 error
	if returnFunc, ok := ret.Get(0).(func(client.ApiListGroupsRequest) ([]string, *http.Response, error)); ok {
		return returnFunc(r)
	}
	if returnFunc, ok := ret.Get(0).(func(client.ApiListGroupsRequest) []string); ok {
		r0 = returnFunc(r)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]string)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(client.ApiListGroupsRequest) *http.Response); ok {
		r1 = returnFunc(r)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*http.Response)
		}
	}
	if returnFunc, ok := ret.Get(2).(func(client.ApiListGroupsRequest) error); ok {
		r2 = returnFunc(r)
	} else {
		r2 = ret.Error(2)
	}
	return r0, r1, r2
}

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

// ListGroupsExecute is a helper method to define mock.On call
//   - r client.ApiListGroupsRequest
func (_e *MockDeviceInventoryManagementAPIAPI_Expecter) ListGroupsExecute(r interface{}) *MockDeviceInventoryManagementAPIAPI_ListGroupsExecute_Call {
	return &MockDeviceInventoryManagementAPIAPI_ListGroupsExecute_Call{Call: _e.mock.On("ListGroupsExecute", r)}
}

func (_c *MockDeviceInventoryManagementAPIAPI_ListGroupsExecute_Call) Run(run func(r client.ApiListGroupsRequest)) *MockDeviceInventoryManagementAPIAPI_ListGroupsExecute_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 client.ApiListGroupsRequest
		if args[0] != nil {
			arg0 = args[0].(client.ApiListGroupsRequest)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *MockDeviceInventoryManagementAPIAPI_ListGroupsExecute_Call) Return(strings []string, response *http.Response, err error) *MockDeviceInventoryManagementAPIAPI_ListGroupsExecute_Call {
	_c.Call.Return(strings, response, err)
	return _c
}

func (_c *MockDeviceInventoryManagementAPIAPI_ListGroupsExecute_Call) RunAndReturn(run func(r client.ApiListGroupsRequest) ([]string, *http.Response, error)) *MockDeviceInventoryManagementAPIAPI_ListGroupsExecute_Call {
	_c.Call.Return(run)
	return _c
}

// RemoveAGroup provides a mock function for the type MockDeviceInventoryManagementAPIAPI
func (_mock *MockDeviceInventoryManagementAPIAPI) RemoveAGroup(ctx context.Context, name string) client.ApiRemoveAGroupRequest {
	ret := _mock.Called(ctx, name)

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

	var r0 client.ApiRemoveAGroupRequest
	if returnFunc, ok := ret.Get(0).(func(context.Context, string) client.ApiRemoveAGroupRequest); ok {
		r0 = returnFunc(ctx, name)
	} else {
		r0 = ret.Get(0).(client.ApiRemoveAGroupRequest)
	}
	return r0
}

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

// RemoveAGroup is a helper method to define mock.On call
//   - ctx context.Context
//   - name string
func (_e *MockDeviceInventoryManagementAPIAPI_Expecter) RemoveAGroup(ctx interface{}, name interface{}) *MockDeviceInventoryManagementAPIAPI_RemoveAGroup_Call {
	return &MockDeviceInventoryManagementAPIAPI_RemoveAGroup_Call{Call: _e.mock.On("RemoveAGroup", ctx, name)}
}

func (_c *MockDeviceInventoryManagementAPIAPI_RemoveAGroup_Call) Run(run func(ctx context.Context, name string)) *MockDeviceInventoryManagementAPIAPI_RemoveAGroup_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 *MockDeviceInventoryManagementAPIAPI_RemoveAGroup_Call) Return(apiRemoveAGroupRequest client.ApiRemoveAGroupRequest) *MockDeviceInventoryManagementAPIAPI_RemoveAGroup_Call {
	_c.Call.Return(apiRemoveAGroupRequest)
	return _c
}

func (_c *MockDeviceInventoryManagementAPIAPI_RemoveAGroup_Call) RunAndReturn(run func(ctx context.Context, name string) client.ApiRemoveAGroupRequest) *MockDeviceInventoryManagementAPIAPI_RemoveAGroup_Call {
	_c.Call.Return(run)
	return _c
}

// RemoveAGroupExecute provides a mock function for the type MockDeviceInventoryManagementAPIAPI
func (_mock *MockDeviceInventoryManagementAPIAPI) RemoveAGroupExecute(r client.ApiRemoveAGroupRequest) (*client.RemoveAGroup200Response, *http.Response, error) {
	ret := _mock.Called(r)

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

	var r0 *client.RemoveAGroup200Response
	var r1 *http.Response
	var r2 error
	if returnFunc, ok := ret.Get(0).(func(client.ApiRemoveAGroupRequest) (*client.RemoveAGroup200Response, *http.Response, error)); ok {
		return returnFunc(r)
	}
	if returnFunc, ok := ret.Get(0).(func(client.ApiRemoveAGroupRequest) *client.RemoveAGroup200Response); ok {
		r0 = returnFunc(r)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*client.RemoveAGroup200Response)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(client.ApiRemoveAGroupRequest) *http.Response); ok {
		r1 = returnFunc(r)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*http.Response)
		}
	}
	if returnFunc, ok := ret.Get(2).(func(client.ApiRemoveAGroupRequest) error); ok {
		r2 = returnFunc(r)
	} else {
		r2 = ret.Error(2)
	}
	return r0, r1, r2
}

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

// RemoveAGroupExecute is a helper method to define mock.On call
//   - r client.ApiRemoveAGroupRequest
func (_e *MockDeviceInventoryManagementAPIAPI_Expecter) RemoveAGroupExecute(r interface{}) *MockDeviceInventoryManagementAPIAPI_RemoveAGroupExecute_Call {
	return &MockDeviceInventoryManagementAPIAPI_RemoveAGroupExecute_Call{Call: _e.mock.On("RemoveAGroupExecute", r)}
}

func (_c *MockDeviceInventoryManagementAPIAPI_RemoveAGroupExecute_Call) Run(run func(r client.ApiRemoveAGroupRequest)) *MockDeviceInventoryManagementAPIAPI_RemoveAGroupExecute_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 client.ApiRemoveAGroupRequest
		if args[0] != nil {
			arg0 = args[0].(client.ApiRemoveAGroupRequest)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *MockDeviceInventoryManagementAPIAPI_RemoveAGroupExecute_Call) Return(removeAGroup200Response *client.RemoveAGroup200Response, response *http.Response, err error) *MockDeviceInventoryManagementAPIAPI_RemoveAGroupExecute_Call {
	_c.Call.Return(removeAGroup200Response, response, err)
	return _c
}

func (_c *MockDeviceInventoryManagementAPIAPI_RemoveAGroupExecute_Call) RunAndReturn(run func(r client.ApiRemoveAGroupRequest) (*client.RemoveAGroup200Response, *http.Response, error)) *MockDeviceInventoryManagementAPIAPI_RemoveAGroupExecute_Call {
	_c.Call.Return(run)
	return _c
}

// RemoveDevicesFromGroup provides a mock function for the type MockDeviceInventoryManagementAPIAPI
func (_mock *MockDeviceInventoryManagementAPIAPI) RemoveDevicesFromGroup(ctx context.Context, name string) client.ApiRemoveDevicesFromGroupRequest {
	ret := _mock.Called(ctx, name)

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

	var r0 client.ApiRemoveDevicesFromGroupRequest
	if returnFunc, ok := ret.Get(0).(func(context.Context, string) client.ApiRemoveDevicesFromGroupRequest); ok {
		r0 = returnFunc(ctx, name)
	} else {
		r0 = ret.Get(0).(client.ApiRemoveDevicesFromGroupRequest)
	}
	return r0
}

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

// RemoveDevicesFromGroup is a helper method to define mock.On call
//   - ctx context.Context
//   - name string
func (_e *MockDeviceInventoryManagementAPIAPI_Expecter) RemoveDevicesFromGroup(ctx interface{}, name interface{}) *MockDeviceInventoryManagementAPIAPI_RemoveDevicesFromGroup_Call {
	return &MockDeviceInventoryManagementAPIAPI_RemoveDevicesFromGroup_Call{Call: _e.mock.On("RemoveDevicesFromGroup", ctx, name)}
}

func (_c *MockDeviceInventoryManagementAPIAPI_RemoveDevicesFromGroup_Call) Run(run func(ctx context.Context, name string)) *MockDeviceInventoryManagementAPIAPI_RemoveDevicesFromGroup_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 *MockDeviceInventoryManagementAPIAPI_RemoveDevicesFromGroup_Call) Return(apiRemoveDevicesFromGroupRequest client.ApiRemoveDevicesFromGroupRequest) *MockDeviceInventoryManagementAPIAPI_RemoveDevicesFromGroup_Call {
	_c.Call.Return(apiRemoveDevicesFromGroupRequest)
	return _c
}

func (_c *MockDeviceInventoryManagementAPIAPI_RemoveDevicesFromGroup_Call) RunAndReturn(run func(ctx context.Context, name string) client.ApiRemoveDevicesFromGroupRequest) *MockDeviceInventoryManagementAPIAPI_RemoveDevicesFromGroup_Call {
	_c.Call.Return(run)
	return _c
}

// RemoveDevicesFromGroupExecute provides a mock function for the type MockDeviceInventoryManagementAPIAPI
func (_mock *MockDeviceInventoryManagementAPIAPI) RemoveDevicesFromGroupExecute(r client.ApiRemoveDevicesFromGroupRequest) (*client.RemoveAGroup200Response, *http.Response, error) {
	ret := _mock.Called(r)

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

	var r0 *client.RemoveAGroup200Response
	var r1 *http.Response
	var r2 error
	if returnFunc, ok := ret.Get(0).(func(client.ApiRemoveDevicesFromGroupRequest) (*client.RemoveAGroup200Response, *http.Response, error)); ok {
		return returnFunc(r)
	}
	if returnFunc, ok := ret.Get(0).(func(client.ApiRemoveDevicesFromGroupRequest) *client.RemoveAGroup200Response); ok {
		r0 = returnFunc(r)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*client.RemoveAGroup200Response)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(client.ApiRemoveDevicesFromGroupRequest) *http.Response); ok {
		r1 = returnFunc(r)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*http.Response)
		}
	}
	if returnFunc, ok := ret.Get(2).(func(client.ApiRemoveDevicesFromGroupRequest) error); ok {
		r2 = returnFunc(r)
	} else {
		r2 = ret.Error(2)
	}
	return r0, r1, r2
}

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

// RemoveDevicesFromGroupExecute is a helper method to define mock.On call
//   - r client.ApiRemoveDevicesFromGroupRequest
func (_e *MockDeviceInventoryManagementAPIAPI_Expecter) RemoveDevicesFromGroupExecute(r interface{}) *MockDeviceInventoryManagementAPIAPI_RemoveDevicesFromGroupExecute_Call {
	return &MockDeviceInventoryManagementAPIAPI_RemoveDevicesFromGroupExecute_Call{Call: _e.mock.On("RemoveDevicesFromGroupExecute", r)}
}

func (_c *MockDeviceInventoryManagementAPIAPI_RemoveDevicesFromGroupExecute_Call) Run(run func(r client.ApiRemoveDevicesFromGroupRequest)) *MockDeviceInventoryManagementAPIAPI_RemoveDevicesFromGroupExecute_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 client.ApiRemoveDevicesFromGroupRequest
		if args[0] != nil {
			arg0 = args[0].(client.ApiRemoveDevicesFromGroupRequest)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *MockDeviceInventoryManagementAPIAPI_RemoveDevicesFromGroupExecute_Call) Return(removeAGroup200Response *client.RemoveAGroup200Response, response *http.Response, err error) *MockDeviceInventoryManagementAPIAPI_RemoveDevicesFromGroupExecute_Call {
	_c.Call.Return(removeAGroup200Response, response, err)
	return _c
}

func (_c *MockDeviceInventoryManagementAPIAPI_RemoveDevicesFromGroupExecute_Call) RunAndReturn(run func(r client.ApiRemoveDevicesFromGroupRequest) (*client.RemoveAGroup200Response, *http.Response, error)) *MockDeviceInventoryManagementAPIAPI_RemoveDevicesFromGroupExecute_Call {
	_c.Call.Return(run)
	return _c
}

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

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

	return mock
}

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

type MockIoTManagerInternalAPIAPI_Expecter struct {
	mock *mock.Mock
}

func (_m *MockIoTManagerInternalAPIAPI) EXPECT() *MockIoTManagerInternalAPIAPI_Expecter {
	return &MockIoTManagerInternalAPIAPI_Expecter{mock: &_m.Mock}
}

// IoTManagerInternalCheckHealth provides a mock function for the type MockIoTManagerInternalAPIAPI
func (_mock *MockIoTManagerInternalAPIAPI) IoTManagerInternalCheckHealth(ctx context.Context) client.ApiIoTManagerInternalCheckHealthRequest {
	ret := _mock.Called(ctx)

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

	var r0 client.ApiIoTManagerInternalCheckHealthRequest
	if returnFunc, ok := ret.Get(0).(func(context.Context) client.ApiIoTManagerInternalCheckHealthRequest); ok {
		r0 = returnFunc(ctx)
	} else {
		r0 = ret.Get(0).(client.ApiIoTManagerInternalCheckHealthRequest)
	}
	return r0
}

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

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

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

func (_c *MockIoTManagerInternalAPIAPI_IoTManagerInternalCheckHealth_Call) Return(apiIoTManagerInternalCheckHealthRequest client.ApiIoTManagerInternalCheckHealthRequest) *MockIoTManagerInternalAPIAPI_IoTManagerInternalCheckHealth_Call {
	_c.Call.Return(apiIoTManagerInternalCheckHealthRequest)
	return _c
}

func (_c *MockIoTManagerInternalAPIAPI_IoTManagerInternalCheckHealth_Call) RunAndReturn(run func(ctx context.Context) client.ApiIoTManagerInternalCheckHealthRequest) *MockIoTManagerInternalAPIAPI_IoTManagerInternalCheckHealth_Call {
	_c.Call.Return(run)
	return _c
}

// IoTManagerInternalCheckHealthExecute provides a mock function for the type MockIoTManagerInternalAPIAPI
func (_mock *MockIoTManagerInternalAPIAPI) IoTManagerInternalCheckHealthExecute(r client.ApiIoTManagerInternalCheckHealthRequest) (*http.Response, error) {
	ret := _mock.Called(r)

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

	var r0 *http.Response
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(client.ApiIoTManagerInternalCheckHealthRequest) (*http.Response, error)); ok {
		return returnFunc(r)
	}
	if returnFunc, ok := ret.Get(0).(func(client.ApiIoTManagerInternalCheckHealthRequest) *http.Response); ok {
		r0 = returnFunc(r)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*http.Response)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(client.ApiIoTManagerInternalCheckHealthRequest) error); ok {
		r1 = returnFunc(r)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// IoTManagerInternalCheckHealthExecute is a helper method to define mock.On call
//   - r client.ApiIoTManagerInternalCheckHealthRequest
func (_e *MockIoTManagerInternalAPIAPI_Expecter) IoTManagerInternalCheckHealthExecute(r interface{}) *MockIoTManagerInternalAPIAPI_IoTManagerInternalCheckHealthExecute_Call {
	return &MockIoTManagerInternalAPIAPI_IoTManagerInternalCheckHealthExecute_Call{Call: _e.mock.On("IoTManagerInternalCheckHealthExecute", r)}
}

func (_c *MockIoTManagerInternalAPIAPI_IoTManagerInternalCheckHealthExecute_Call) Run(run func(r client.ApiIoTManagerInternalCheckHealthRequest)) *MockIoTManagerInternalAPIAPI_IoTManagerInternalCheckHealthExecute_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 client.ApiIoTManagerInternalCheckHealthRequest
		if args[0] != nil {
			arg0 = args[0].(client.ApiIoTManagerInternalCheckHealthRequest)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *MockIoTManagerInternalAPIAPI_IoTManagerInternalCheckHealthExecute_Call) Return(response *http.Response, err error) *MockIoTManagerInternalAPIAPI_IoTManagerInternalCheckHealthExecute_Call {
	_c.Call.Return(response, err)
	return _c
}

func (_c *MockIoTManagerInternalAPIAPI_IoTManagerInternalCheckHealthExecute_Call) RunAndReturn(run func(r client.ApiIoTManagerInternalCheckHealthRequest) (*http.Response, error)) *MockIoTManagerInternalAPIAPI_IoTManagerInternalCheckHealthExecute_Call {
	_c.Call.Return(run)
	return _c
}

// IoTManagerInternalCheckLiveliness provides a mock function for the type MockIoTManagerInternalAPIAPI
func (_mock *MockIoTManagerInternalAPIAPI) IoTManagerInternalCheckLiveliness(ctx context.Context) client.ApiIoTManagerInternalCheckLivelinessRequest {
	ret := _mock.Called(ctx)

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

	var r0 client.ApiIoTManagerInternalCheckLivelinessRequest
	if returnFunc, ok := ret.Get(0).(func(context.Context) client.ApiIoTManagerInternalCheckLivelinessRequest); ok {
		r0 = returnFunc(ctx)
	} else {
		r0 = ret.Get(0).(client.ApiIoTManagerInternalCheckLivelinessRequest)
	}
	return r0
}

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

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

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

func (_c *MockIoTManagerInternalAPIAPI_IoTManagerInternalCheckLiveliness_Call) Return(apiIoTManagerInternalCheckLivelinessRequest client.ApiIoTManagerInternalCheckLivelinessRequest) *MockIoTManagerInternalAPIAPI_IoTManagerInternalCheckLiveliness_Call {
	_c.Call.Return(apiIoTManagerInternalCheckLivelinessRequest)
	return _c
}

func (_c *MockIoTManagerInternalAPIAPI_IoTManagerInternalCheckLiveliness_Call) RunAndReturn(run func(ctx context.Context) client.ApiIoTManagerInternalCheckLivelinessRequest) *MockIoTManagerInternalAPIAPI_IoTManagerInternalCheckLiveliness_Call {
	_c.Call.Return(run)
	return _c
}

// IoTManagerInternalCheckLivelinessExecute provides a mock function for the type MockIoTManagerInternalAPIAPI
func (_mock *MockIoTManagerInternalAPIAPI) IoTManagerInternalCheckLivelinessExecute(r client.ApiIoTManagerInternalCheckLivelinessRequest) (*http.Response, error) {
	ret := _mock.Called(r)

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

	var r0 *http.Response
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(client.ApiIoTManagerInternalCheckLivelinessRequest) (*http.Response, error)); ok {
		return returnFunc(r)
	}
	if returnFunc, ok := ret.Get(0).(func(client.ApiIoTManagerInternalCheckLivelinessRequest) *http.Response); ok {
		r0 = returnFunc(r)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*http.Response)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(client.ApiIoTManagerInternalCheckLivelinessRequest) error); ok {
		r1 = returnFunc(r)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// IoTManagerInternalCheckLivelinessExecute is a helper method to define mock.On call
//   - r client.ApiIoTManagerInternalCheckLivelinessRequest
func (_e *MockIoTManagerInternalAPIAPI_Expecter) IoTManagerInternalCheckLivelinessExecute(r interface{}) *MockIoTManagerInternalAPIAPI_IoTManagerInternalCheckLivelinessExecute_Call {
	return &MockIoTManagerInternalAPIAPI_IoTManagerInternalCheckLivelinessExecute_Call{Call: _e.mock.On("IoTManagerInternalCheckLivelinessExecute", r)}
}

func (_c *MockIoTManagerInternalAPIAPI_IoTManagerInternalCheckLivelinessExecute_Call) Run(run func(r client.ApiIoTManagerInternalCheckLivelinessRequest)) *MockIoTManagerInternalAPIAPI_IoTManagerInternalCheckLivelinessExecute_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 client.ApiIoTManagerInternalCheckLivelinessRequest
		if args[0] != nil {
			arg0 = args[0].(client.ApiIoTManagerInternalCheckLivelinessRequest)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *MockIoTManagerInternalAPIAPI_IoTManagerInternalCheckLivelinessExecute_Call) Return(response *http.Response, err error) *MockIoTManagerInternalAPIAPI_IoTManagerInternalCheckLivelinessExecute_Call {
	_c.Call.Return(response, err)
	return _c
}

func (_c *MockIoTManagerInternalAPIAPI_IoTManagerInternalCheckLivelinessExecute_Call) RunAndReturn(run func(r client.ApiIoTManagerInternalCheckLivelinessRequest) (*http.Response, error)) *MockIoTManagerInternalAPIAPI_IoTManagerInternalCheckLivelinessExecute_Call {
	_c.Call.Return(run)
	return _c
}

// IoTManagerInternalDecommissionDevice provides a mock function for the type MockIoTManagerInternalAPIAPI
func (_mock *MockIoTManagerInternalAPIAPI) IoTManagerInternalDecommissionDevice(ctx context.Context, tenantId string, deviceId string) client.ApiIoTManagerInternalDecommissionDeviceRequest {
	ret := _mock.Called(ctx, tenantId, deviceId)

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

	var r0 client.ApiIoTManagerInternalDecommissionDeviceRequest
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string) client.ApiIoTManagerInternalDecommissionDeviceRequest); ok {
		r0 = returnFunc(ctx, tenantId, deviceId)
	} else {
		r0 = ret.Get(0).(client.ApiIoTManagerInternalDecommissionDeviceRequest)
	}
	return r0
}

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

// IoTManagerInternalDecommissionDevice is a helper method to define mock.On call
//   - ctx context.Context
//   - tenantId string
//   - deviceId string
func (_e *MockIoTManagerInternalAPIAPI_Expecter) IoTManagerInternalDecommissionDevice(ctx interface{}, tenantId interface{}, deviceId interface{}) *MockIoTManagerInternalAPIAPI_IoTManagerInternalDecommissionDevice_Call {
	return &MockIoTManagerInternalAPIAPI_IoTManagerInternalDecommissionDevice_Call{Call: _e.mock.On("IoTManagerInternalDecommissionDevice", ctx, tenantId, deviceId)}
}

func (_c *MockIoTManagerInternalAPIAPI_IoTManagerInternalDecommissionDevice_Call) Run(run func(ctx context.Context, tenantId string, deviceId string)) *MockIoTManagerInternalAPIAPI_IoTManagerInternalDecommissionDevice_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)
		}
		run(
			arg0,
			arg1,
			arg2,
		)
	})
	return _c
}

func (_c *MockIoTManagerInternalAPIAPI_IoTManagerInternalDecommissionDevice_Call) Return(apiIoTManagerInternalDecommissionDeviceRequest client.ApiIoTManagerInternalDecommissionDeviceRequest) *MockIoTManagerInternalAPIAPI_IoTManagerInternalDecommissionDevice_Call {
	_c.Call.Return(apiIoTManagerInternalDecommissionDeviceRequest)
	return _c
}

func (_c *MockIoTManagerInternalAPIAPI_IoTManagerInternalDecommissionDevice_Call) RunAndReturn(run func(ctx context.Context, tenantId string, deviceId string) client.ApiIoTManagerInternalDecommissionDeviceRequest) *MockIoTManagerInternalAPIAPI_IoTManagerInternalDecommissionDevice_Call {
	_c.Call.Return(run)
	return _c
}

// IoTManagerInternalDecommissionDeviceExecute provides a mock function for the type MockIoTManagerInternalAPIAPI
func (_mock *MockIoTManagerInternalAPIAPI) IoTManagerInternalDecommissionDeviceExecute(r client.ApiIoTManagerInternalDecommissionDeviceRequest) (*http.Response, error) {
	ret := _mock.Called(r)

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

	var r0 *http.Response
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(client.ApiIoTManagerInternalDecommissionDeviceRequest) (*http.Response, error)); ok {
		return returnFunc(r)
	}
	if returnFunc, ok := ret.Get(0).(func(client.ApiIoTManagerInternalDecommissionDeviceRequest) *http.Response); ok {
		r0 = returnFunc(r)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*http.Response)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(client.ApiIoTManagerInternalDecommissionDeviceRequest) error); ok {
		r1 = returnFunc(r)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// IoTManagerInternalDecommissionDeviceExecute is a helper method to define mock.On call
//   - r client.ApiIoTManagerInternalDecommissionDeviceRequest
func (_e *MockIoTManagerInternalAPIAPI_Expecter) IoTManagerInternalDecommissionDeviceExecute(r interface{}) *MockIoTManagerInternalAPIAPI_IoTManagerInternalDecommissionDeviceExecute_Call {
	return &MockIoTManagerInternalAPIAPI_IoTManagerInternalDecommissionDeviceExecute_Call{Call: _e.mock.On("IoTManagerInternalDecommissionDeviceExecute", r)}
}

func (_c *MockIoTManagerInternalAPIAPI_IoTManagerInternalDecommissionDeviceExecute_Call) Run(run func(r client.ApiIoTManagerInternalDecommissionDeviceRequest)) *MockIoTManagerInternalAPIAPI_IoTManagerInternalDecommissionDeviceExecute_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 client.ApiIoTManagerInternalDecommissionDeviceRequest
		if args[0] != nil {
			arg0 = args[0].(client.ApiIoTManagerInternalDecommissionDeviceRequest)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *MockIoTManagerInternalAPIAPI_IoTManagerInternalDecommissionDeviceExecute_Call) Return(response *http.Response, err error) *MockIoTManagerInternalAPIAPI_IoTManagerInternalDecommissionDeviceExecute_Call {
	_c.Call.Return(response, err)
	return _c
}

func (_c *MockIoTManagerInternalAPIAPI_IoTManagerInternalDecommissionDeviceExecute_Call) RunAndReturn(run func(r client.ApiIoTManagerInternalDecommissionDeviceRequest) (*http.Response, error)) *MockIoTManagerInternalAPIAPI_IoTManagerInternalDecommissionDeviceExecute_Call {
	_c.Call.Return(run)
	return _c
}

// IoTManagerInternalDeleteTenant provides a mock function for the type MockIoTManagerInternalAPIAPI
func (_mock *MockIoTManagerInternalAPIAPI) IoTManagerInternalDeleteTenant(ctx context.Context, tenantId string) client.ApiIoTManagerInternalDeleteTenantRequest {
	ret := _mock.Called(ctx, tenantId)

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

	var r0 client.ApiIoTManagerInternalDeleteTenantRequest
	if returnFunc, ok := ret.Get(0).(func(context.Context, string) client.ApiIoTManagerInternalDeleteTenantRequest); ok {
		r0 = returnFunc(ctx, tenantId)
	} else {
		r0 = ret.Get(0).(client.ApiIoTManagerInternalDeleteTenantRequest)
	}
	return r0
}

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

// IoTManagerInternalDeleteTenant is a helper method to define mock.On call
//   - ctx context.Context
//   - tenantId string
func (_e *MockIoTManagerInternalAPIAPI_Expecter) IoTManagerInternalDeleteTenant(ctx interface{}, tenantId interface{}) *MockIoTManagerInternalAPIAPI_IoTManagerInternalDeleteTenant_Call {
	return &MockIoTManagerInternalAPIAPI_IoTManagerInternalDeleteTenant_Call{Call: _e.mock.On("IoTManagerInternalDeleteTenant", ctx, tenantId)}
}

func (_c *MockIoTManagerInternalAPIAPI_IoTManagerInternalDeleteTenant_Call) Run(run func(ctx context.Context, tenantId string)) *MockIoTManagerInternalAPIAPI_IoTManagerInternalDeleteTenant_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 *MockIoTManagerInternalAPIAPI_IoTManagerInternalDeleteTenant_Call) Return(apiIoTManagerInternalDeleteTenantRequest client.ApiIoTManagerInternalDeleteTenantRequest) *MockIoTManagerInternalAPIAPI_IoTManagerInternalDeleteTenant_Call {
	_c.Call.Return(apiIoTManagerInternalDeleteTenantRequest)
	return _c
}

func (_c *MockIoTManagerInternalAPIAPI_IoTManagerInternalDeleteTenant_Call) RunAndReturn(run func(ctx context.Context, tenantId string) client.ApiIoTManagerInternalDeleteTenantRequest) *MockIoTManagerInternalAPIAPI_IoTManagerInternalDeleteTenant_Call {
	_c.Call.Return(run)
	return _c
}

// IoTManagerInternalDeleteTenantExecute provides a mock function for the type MockIoTManagerInternalAPIAPI
func (_mock *MockIoTManagerInternalAPIAPI) IoTManagerInternalDeleteTenantExecute(r client.ApiIoTManagerInternalDeleteTenantRequest) (*http.Response, error) {
	ret := _mock.Called(r)

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

	var r0 *http.Response
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(client.ApiIoTManagerInternalDeleteTenantRequest) (*http.Response, error)); ok {
		return returnFunc(r)
	}
	if returnFunc, ok := ret.Get(0).(func(client.ApiIoTManagerInternalDeleteTenantRequest) *http.Response); ok {
		r0 = returnFunc(r)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*http.Response)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(client.ApiIoTManagerInternalDeleteTenantRequest) error); ok {
		r1 = returnFunc(r)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// IoTManagerInternalDeleteTenantExecute is a helper method to define mock.On call
//   - r client.ApiIoTManagerInternalDeleteTenantRequest
func (_e *MockIoTManagerInternalAPIAPI_Expecter) IoTManagerInternalDeleteTenantExecute(r interface{}) *MockIoTManagerInternalAPIAPI_IoTManagerInternalDeleteTenantExecute_Call {
	return &MockIoTManagerInternalAPIAPI_IoTManagerInternalDeleteTenantExecute_Call{Call: _e.mock.On("IoTManagerInternalDeleteTenantExecute", r)}
}

func (_c *MockIoTManagerInternalAPIAPI_IoTManagerInternalDeleteTenantExecute_Call) Run(run func(r client.ApiIoTManagerInternalDeleteTenantRequest)) *MockIoTManagerInternalAPIAPI_IoTManagerInternalDeleteTenantExecute_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 client.ApiIoTManagerInternalDeleteTenantRequest
		if args[0] != nil {
			arg0 = args[0].(client.ApiIoTManagerInternalDeleteTenantRequest)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *MockIoTManagerInternalAPIAPI_IoTManagerInternalDeleteTenantExecute_Call) Return(response *http.Response, err error) *MockIoTManagerInternalAPIAPI_IoTManagerInternalDeleteTenantExecute_Call {
	_c.Call.Return(response, err)
	return _c
}

func (_c *MockIoTManagerInternalAPIAPI_IoTManagerInternalDeleteTenantExecute_Call) RunAndReturn(run func(r client.ApiIoTManagerInternalDeleteTenantRequest) (*http.Response, error)) *MockIoTManagerInternalAPIAPI_IoTManagerInternalDeleteTenantExecute_Call {
	_c.Call.Return(run)
	return _c
}

// IoTManagerInternalProvisionDevice provides a mock function for the type MockIoTManagerInternalAPIAPI
func (_mock *MockIoTManagerInternalAPIAPI) IoTManagerInternalProvisionDevice(ctx context.Context, tenantId string) client.ApiIoTManagerInternalProvisionDeviceRequest {
	ret := _mock.Called(ctx, tenantId)

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

	var r0 client.ApiIoTManagerInternalProvisionDeviceRequest
	if returnFunc, ok := ret.Get(0).(func(context.Context, string) client.ApiIoTManagerInternalProvisionDeviceRequest); ok {
		r0 = returnFunc(ctx, tenantId)
	} else {
		r0 = ret.Get(0).(client.ApiIoTManagerInternalProvisionDeviceRequest)
	}
	return r0
}

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

// IoTManagerInternalProvisionDevice is a helper method to define mock.On call
//   - ctx context.Context
//   - tenantId string
func (_e *MockIoTManagerInternalAPIAPI_Expecter) IoTManagerInternalProvisionDevice(ctx interface{}, tenantId interface{}) *MockIoTManagerInternalAPIAPI_IoTManagerInternalProvisionDevice_Call {
	return &MockIoTManagerInternalAPIAPI_IoTManagerInternalProvisionDevice_Call{Call: _e.mock.On("IoTManagerInternalProvisionDevice", ctx, tenantId)}
}

func (_c *MockIoTManagerInternalAPIAPI_IoTManagerInternalProvisionDevice_Call) Run(run func(ctx context.Context, tenantId string)) *MockIoTManagerInternalAPIAPI_IoTManagerInternalProvisionDevice_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 *MockIoTManagerInternalAPIAPI_IoTManagerInternalProvisionDevice_Call) Return(apiIoTManagerInternalProvisionDeviceRequest client.ApiIoTManagerInternalProvisionDeviceRequest) *MockIoTManagerInternalAPIAPI_IoTManagerInternalProvisionDevice_Call {
	_c.Call.Return(apiIoTManagerInternalProvisionDeviceRequest)
	return _c
}

func (_c *MockIoTManagerInternalAPIAPI_IoTManagerInternalProvisionDevice_Call) RunAndReturn(run func(ctx context.Context, tenantId string) client.ApiIoTManagerInternalProvisionDeviceRequest) *MockIoTManagerInternalAPIAPI_IoTManagerInternalProvisionDevice_Call {
	_c.Call.Return(run)
	return _c
}

// IoTManagerInternalProvisionDeviceExecute provides a mock function for the type MockIoTManagerInternalAPIAPI
func (_mock *MockIoTManagerInternalAPIAPI) IoTManagerInternalProvisionDeviceExecute(r client.ApiIoTManagerInternalProvisionDeviceRequest) (*http.Response, error) {
	ret := _mock.Called(r)

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

	var r0 *http.Response
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(client.ApiIoTManagerInternalProvisionDeviceRequest) (*http.Response, error)); ok {
		return returnFunc(r)
	}
	if returnFunc, ok := ret.Get(0).(func(client.ApiIoTManagerInternalProvisionDeviceRequest) *http.Response); ok {
		r0 = returnFunc(r)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*http.Response)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(client.ApiIoTManagerInternalProvisionDeviceRequest) error); ok {
		r1 = returnFunc(r)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// IoTManagerInternalProvisionDeviceExecute is a helper method to define mock.On call
//   - r client.ApiIoTManagerInternalProvisionDeviceRequest
func (_e *MockIoTManagerInternalAPIAPI_Expecter) IoTManagerInternalProvisionDeviceExecute(r interface{}) *MockIoTManagerInternalAPIAPI_IoTManagerInternalProvisionDeviceExecute_Call {
	return &MockIoTManagerInternalAPIAPI_IoTManagerInternalProvisionDeviceExecute_Call{Call: _e.mock.On("IoTManagerInternalProvisionDeviceExecute", r)}
}

func (_c *MockIoTManagerInternalAPIAPI_IoTManagerInternalProvisionDeviceExecute_Call) Run(run func(r client.ApiIoTManagerInternalProvisionDeviceRequest)) *MockIoTManagerInternalAPIAPI_IoTManagerInternalProvisionDeviceExecute_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 client.ApiIoTManagerInternalProvisionDeviceRequest
		if args[0] != nil {
			arg0 = args[0].(client.ApiIoTManagerInternalProvisionDeviceRequest)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *MockIoTManagerInternalAPIAPI_IoTManagerInternalProvisionDeviceExecute_Call) Return(response *http.Response, err error) *MockIoTManagerInternalAPIAPI_IoTManagerInternalProvisionDeviceExecute_Call {
	_c.Call.Return(response, err)
	return _c
}

func (_c *MockIoTManagerInternalAPIAPI_IoTManagerInternalProvisionDeviceExecute_Call) RunAndReturn(run func(r client.ApiIoTManagerInternalProvisionDeviceRequest) (*http.Response, error)) *MockIoTManagerInternalAPIAPI_IoTManagerInternalProvisionDeviceExecute_Call {
	_c.Call.Return(run)
	return _c
}

// IoTManagerInternalUpdateDeviceStatuses provides a mock function for the type MockIoTManagerInternalAPIAPI
func (_mock *MockIoTManagerInternalAPIAPI) IoTManagerInternalUpdateDeviceStatuses(ctx context.Context, tenantId string, status string) client.ApiIoTManagerInternalUpdateDeviceStatusesRequest {
	ret := _mock.Called(ctx, tenantId, status)

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

	var r0 client.ApiIoTManagerInternalUpdateDeviceStatusesRequest
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string) client.ApiIoTManagerInternalUpdateDeviceStatusesRequest); ok {
		r0 = returnFunc(ctx, tenantId, status)
	} else {
		r0 = ret.Get(0).(client.ApiIoTManagerInternalUpdateDeviceStatusesRequest)
	}
	return r0
}

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

// IoTManagerInternalUpdateDeviceStatuses is a helper method to define mock.On call
//   - ctx context.Context
//   - tenantId string
//   - status string
func (_e *MockIoTManagerInternalAPIAPI_Expecter) IoTManagerInternalUpdateDeviceStatuses(ctx interface{}, tenantId interface{}, status interface{}) *MockIoTManagerInternalAPIAPI_IoTManagerInternalUpdateDeviceStatuses_Call {
	return &MockIoTManagerInternalAPIAPI_IoTManagerInternalUpdateDeviceStatuses_Call{Call: _e.mock.On("IoTManagerInternalUpdateDeviceStatuses", ctx, tenantId, status)}
}

func (_c *MockIoTManagerInternalAPIAPI_IoTManagerInternalUpdateDeviceStatuses_Call) Run(run func(ctx context.Context, tenantId string, status string)) *MockIoTManagerInternalAPIAPI_IoTManagerInternalUpdateDeviceStatuses_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)
		}
		run(
			arg0,
			arg1,
			arg2,
		)
	})
	return _c
}

func (_c *MockIoTManagerInternalAPIAPI_IoTManagerInternalUpdateDeviceStatuses_Call) Return(apiIoTManagerInternalUpdateDeviceStatusesRequest client.ApiIoTManagerInternalUpdateDeviceStatusesRequest) *MockIoTManagerInternalAPIAPI_IoTManagerInternalUpdateDeviceStatuses_Call {
	_c.Call.Return(apiIoTManagerInternalUpdateDeviceStatusesRequest)
	return _c
}

func (_c *MockIoTManagerInternalAPIAPI_IoTManagerInternalUpdateDeviceStatuses_Call) RunAndReturn(run func(ctx context.Context, tenantId string, status string) client.ApiIoTManagerInternalUpdateDeviceStatusesRequest) *MockIoTManagerInternalAPIAPI_IoTManagerInternalUpdateDeviceStatuses_Call {
	_c.Call.Return(run)
	return _c
}

// IoTManagerInternalUpdateDeviceStatusesExecute provides a mock function for the type MockIoTManagerInternalAPIAPI
func (_mock *MockIoTManagerInternalAPIAPI) IoTManagerInternalUpdateDeviceStatusesExecute(r client.ApiIoTManagerInternalUpdateDeviceStatusesRequest) (*http.Response, error) {
	ret := _mock.Called(r)

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

	var r0 *http.Response
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(client.ApiIoTManagerInternalUpdateDeviceStatusesRequest) (*http.Response, error)); ok {
		return returnFunc(r)
	}
	if returnFunc, ok := ret.Get(0).(func(client.ApiIoTManagerInternalUpdateDeviceStatusesRequest) *http.Response); ok {
		r0 = returnFunc(r)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*http.Response)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(client.ApiIoTManagerInternalUpdateDeviceStatusesRequest) error); ok {
		r1 = returnFunc(r)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// IoTManagerInternalUpdateDeviceStatusesExecute is a helper method to define mock.On call
//   - r client.ApiIoTManagerInternalUpdateDeviceStatusesRequest
func (_e *MockIoTManagerInternalAPIAPI_Expecter) IoTManagerInternalUpdateDeviceStatusesExecute(r interface{}) *MockIoTManagerInternalAPIAPI_IoTManagerInternalUpdateDeviceStatusesExecute_Call {
	return &MockIoTManagerInternalAPIAPI_IoTManagerInternalUpdateDeviceStatusesExecute_Call{Call: _e.mock.On("IoTManagerInternalUpdateDeviceStatusesExecute", r)}
}

func (_c *MockIoTManagerInternalAPIAPI_IoTManagerInternalUpdateDeviceStatusesExecute_Call) Run(run func(r client.ApiIoTManagerInternalUpdateDeviceStatusesRequest)) *MockIoTManagerInternalAPIAPI_IoTManagerInternalUpdateDeviceStatusesExecute_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 client.ApiIoTManagerInternalUpdateDeviceStatusesRequest
		if args[0] != nil {
			arg0 = args[0].(client.ApiIoTManagerInternalUpdateDeviceStatusesRequest)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *MockIoTManagerInternalAPIAPI_IoTManagerInternalUpdateDeviceStatusesExecute_Call) Return(response *http.Response, err error) *MockIoTManagerInternalAPIAPI_IoTManagerInternalUpdateDeviceStatusesExecute_Call {
	_c.Call.Return(response, err)
	return _c
}

func (_c *MockIoTManagerInternalAPIAPI_IoTManagerInternalUpdateDeviceStatusesExecute_Call) RunAndReturn(run func(r client.ApiIoTManagerInternalUpdateDeviceStatusesRequest) (*http.Response, error)) *MockIoTManagerInternalAPIAPI_IoTManagerInternalUpdateDeviceStatusesExecute_Call {
	_c.Call.Return(run)
	return _c
}

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

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

	return mock
}

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

type MockIoTManagerManagementAPIAPI_Expecter struct {
	mock *mock.Mock
}

func (_m *MockIoTManagerManagementAPIAPI) EXPECT() *MockIoTManagerManagementAPIAPI_Expecter {
	return &MockIoTManagerManagementAPIAPI_Expecter{mock: &_m.Mock}
}

// IoTManagerManagementGetDeviceState provides a mock function for the type MockIoTManagerManagementAPIAPI
func (_mock *MockIoTManagerManagementAPIAPI) IoTManagerManagementGetDeviceState(ctx context.Context, deviceId string, integrationId string) client.ApiIoTManagerManagementGetDeviceStateRequest {
	ret := _mock.Called(ctx, deviceId, integrationId)

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

	var r0 client.ApiIoTManagerManagementGetDeviceStateRequest
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string) client.ApiIoTManagerManagementGetDeviceStateRequest); ok {
		r0 = returnFunc(ctx, deviceId, integrationId)
	} else {
		r0 = ret.Get(0).(client.ApiIoTManagerManagementGetDeviceStateRequest)
	}
	return r0
}

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

// IoTManagerManagementGetDeviceState is a helper method to define mock.On call
//   - ctx context.Context
//   - deviceId string
//   - integrationId string
func (_e *MockIoTManagerManagementAPIAPI_Expecter) IoTManagerManagementGetDeviceState(ctx interface{}, deviceId interface{}, integrationId interface{}) *MockIoTManagerManagementAPIAPI_IoTManagerManagementGetDeviceState_Call {
	return &MockIoTManagerManagementAPIAPI_IoTManagerManagementGetDeviceState_Call{Call: _e.mock.On("IoTManagerManagementGetDeviceState", ctx, deviceId, integrationId)}
}

func (_c *MockIoTManagerManagementAPIAPI_IoTManagerManagementGetDeviceState_Call) Run(run func(ctx context.Context, deviceId string, integrationId string)) *MockIoTManagerManagementAPIAPI_IoTManagerManagementGetDeviceState_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)
		}
		run(
			arg0,
			arg1,
			arg2,
		)
	})
	return _c
}

func (_c *MockIoTManagerManagementAPIAPI_IoTManagerManagementGetDeviceState_Call) Return(apiIoTManagerManagementGetDeviceStateRequest client.ApiIoTManagerManagementGetDeviceStateRequest) *MockIoTManagerManagementAPIAPI_IoTManagerManagementGetDeviceState_Call {
	_c.Call.Return(apiIoTManagerManagementGetDeviceStateRequest)
	return _c
}

func (_c *MockIoTManagerManagementAPIAPI_IoTManagerManagementGetDeviceState_Call) RunAndReturn(run func(ctx context.Context, deviceId string, integrationId string) client.ApiIoTManagerManagementGetDeviceStateRequest) *MockIoTManagerManagementAPIAPI_IoTManagerManagementGetDeviceState_Call {
	_c.Call.Return(run)
	return _c
}

// IoTManagerManagementGetDeviceStateExecute provides a mock function for the type MockIoTManagerManagementAPIAPI
func (_mock *MockIoTManagerManagementAPIAPI) IoTManagerManagementGetDeviceStateExecute(r client.ApiIoTManagerManagementGetDeviceStateRequest) (*client.DeviceState, *http.Response, error) {
	ret := _mock.Called(r)

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

	var r0 *client.DeviceState
	var r1 *http.Response
	var r2 error
	if returnFunc, ok := ret.Get(0).(func(client.ApiIoTManagerManagementGetDeviceStateRequest) (*client.DeviceState, *http.Response, error)); ok {
		return returnFunc(r)
	}
	if returnFunc, ok := ret.Get(0).(func(client.ApiIoTManagerManagementGetDeviceStateRequest) *client.DeviceState); ok {
		r0 = returnFunc(r)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*client.DeviceState)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(client.ApiIoTManagerManagementGetDeviceStateRequest) *http.Response); ok {
		r1 = returnFunc(r)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*http.Response)
		}
	}
	if returnFunc, ok := ret.Get(2).(func(client.ApiIoTManagerManagementGetDeviceStateRequest) error); ok {
		r2 = returnFunc(r)
	} else {
		r2 = ret.Error(2)
	}
	return r0, r1, r2
}

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

// IoTManagerManagementGetDeviceStateExecute is a helper method to define mock.On call
//   - r client.ApiIoTManagerManagementGetDeviceStateRequest
func (_e *MockIoTManagerManagementAPIAPI_Expecter) IoTManagerManagementGetDeviceStateExecute(r interface{}) *MockIoTManagerManagementAPIAPI_IoTManagerManagementGetDeviceStateExecute_Call {
	return &MockIoTManagerManagementAPIAPI_IoTManagerManagementGetDeviceStateExecute_Call{Call: _e.mock.On("IoTManagerManagementGetDeviceStateExecute", r)}
}

func (_c *MockIoTManagerManagementAPIAPI_IoTManagerManagementGetDeviceStateExecute_Call) Run(run func(r client.ApiIoTManagerManagementGetDeviceStateRequest)) *MockIoTManagerManagementAPIAPI_IoTManagerManagementGetDeviceStateExecute_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 client.ApiIoTManagerManagementGetDeviceStateRequest
		if args[0] != nil {
			arg0 = args[0].(client.ApiIoTManagerManagementGetDeviceStateRequest)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *MockIoTManagerManagementAPIAPI_IoTManagerManagementGetDeviceStateExecute_Call) Return(deviceState *client.DeviceState, response *http.Response, err error) *MockIoTManagerManagementAPIAPI_IoTManagerManagementGetDeviceStateExecute_Call {
	_c.Call.Return(deviceState, response, err)
	return _c
}

func (_c *MockIoTManagerManagementAPIAPI_IoTManagerManagementGetDeviceStateExecute_Call) RunAndReturn(run func(r client.ApiIoTManagerManagementGetDeviceStateRequest) (*client.DeviceState, *http.Response, error)) *MockIoTManagerManagementAPIAPI_IoTManagerManagementGetDeviceStateExecute_Call {
	_c.Call.Return(run)
	return _c
}

// IoTManagerManagementGetDeviceStates provides a mock function for the type MockIoTManagerManagementAPIAPI
func (_mock *MockIoTManagerManagementAPIAPI) IoTManagerManagementGetDeviceStates(ctx context.Context, deviceId string) client.ApiIoTManagerManagementGetDeviceStatesRequest {
	ret := _mock.Called(ctx, deviceId)

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

	var r0 client.ApiIoTManagerManagementGetDeviceStatesRequest
	if returnFunc, ok := ret.Get(0).(func(context.Context, string) client.ApiIoTManagerManagementGetDeviceStatesRequest); ok {
		r0 = returnFunc(ctx, deviceId)
	} else {
		r0 = ret.Get(0).(client.ApiIoTManagerManagementGetDeviceStatesRequest)
	}
	return r0
}

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

// IoTManagerManagementGetDeviceStates is a helper method to define mock.On call
//   - ctx context.Context
//   - deviceId string
func (_e *MockIoTManagerManagementAPIAPI_Expecter) IoTManagerManagementGetDeviceStates(ctx interface{}, deviceId interface{}) *MockIoTManagerManagementAPIAPI_IoTManagerManagementGetDeviceStates_Call {
	return &MockIoTManagerManagementAPIAPI_IoTManagerManagementGetDeviceStates_Call{Call: _e.mock.On("IoTManagerManagementGetDeviceStates", ctx, deviceId)}
}

func (_c *MockIoTManagerManagementAPIAPI_IoTManagerManagementGetDeviceStates_Call) Run(run func(ctx context.Context, deviceId string)) *MockIoTManagerManagementAPIAPI_IoTManagerManagementGetDeviceStates_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 *MockIoTManagerManagementAPIAPI_IoTManagerManagementGetDeviceStates_Call) Return(apiIoTManagerManagementGetDeviceStatesRequest client.ApiIoTManagerManagementGetDeviceStatesRequest) *MockIoTManagerManagementAPIAPI_IoTManagerManagementGetDeviceStates_Call {
	_c.Call.Return(apiIoTManagerManagementGetDeviceStatesRequest)
	return _c
}

func (_c *MockIoTManagerManagementAPIAPI_IoTManagerManagementGetDeviceStates_Call) RunAndReturn(run func(ctx context.Context, deviceId string) client.ApiIoTManagerManagementGetDeviceStatesRequest) *MockIoTManagerManagementAPIAPI_IoTManagerManagementGetDeviceStates_Call {
	_c.Call.Return(run)
	return _c
}

// IoTManagerManagementGetDeviceStatesExecute provides a mock function for the type MockIoTManagerManagementAPIAPI
func (_mock *MockIoTManagerManagementAPIAPI) IoTManagerManagementGetDeviceStatesExecute(r client.ApiIoTManagerManagementGetDeviceStatesRequest) (*map[string]client.DeviceState, *http.Response, error) {
	ret := _mock.Called(r)

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

	var r0 *map[string]client.DeviceState
	var r1 *http.Response
	var r2 error
	if returnFunc, ok := ret.Get(0).(func(client.ApiIoTManagerManagementGetDeviceStatesRequest) (*map[string]client.DeviceState, *http.Response, error)); ok {
		return returnFunc(r)
	}
	if returnFunc, ok := ret.Get(0).(func(client.ApiIoTManagerManagementGetDeviceStatesRequest) *map[string]client.DeviceState); ok {
		r0 = returnFunc(r)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*map[string]client.DeviceState)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(client.ApiIoTManagerManagementGetDeviceStatesRequest) *http.Response); ok {
		r1 = returnFunc(r)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*http.Response)
		}
	}
	if returnFunc, ok := ret.Get(2).(func(client.ApiIoTManagerManagementGetDeviceStatesRequest) error); ok {
		r2 = returnFunc(r)
	} else {
		r2 = ret.Error(2)
	}
	return r0, r1, r2
}

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

// IoTManagerManagementGetDeviceStatesExecute is a helper method to define mock.On call
//   - r client.ApiIoTManagerManagementGetDeviceStatesRequest
func (_e *MockIoTManagerManagementAPIAPI_Expecter) IoTManagerManagementGetDeviceStatesExecute(r interface{}) *MockIoTManagerManagementAPIAPI_IoTManagerManagementGetDeviceStatesExecute_Call {
	return &MockIoTManagerManagementAPIAPI_IoTManagerManagementGetDeviceStatesExecute_Call{Call: _e.mock.On("IoTManagerManagementGetDeviceStatesExecute", r)}
}

func (_c *MockIoTManagerManagementAPIAPI_IoTManagerManagementGetDeviceStatesExecute_Call) Run(run func(r client.ApiIoTManagerManagementGetDeviceStatesRequest)) *MockIoTManagerManagementAPIAPI_IoTManagerManagementGetDeviceStatesExecute_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 client.ApiIoTManagerManagementGetDeviceStatesRequest
		if args[0] != nil {
			arg0 = args[0].(client.ApiIoTManagerManagementGetDeviceStatesRequest)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *MockIoTManagerManagementAPIAPI_IoTManagerManagementGetDeviceStatesExecute_Call) Return(stringToDeviceState *map[string]client.DeviceState, response *http.Response, err error) *MockIoTManagerManagementAPIAPI_IoTManagerManagementGetDeviceStatesExecute_Call {
	_c.Call.Return(stringToDeviceState, response, err)
	return _c
}

func (_c *MockIoTManagerManagementAPIAPI_IoTManagerManagementGetDeviceStatesExecute_Call) RunAndReturn(run func(r client.ApiIoTManagerManagementGetDeviceStatesRequest) (*map[string]client.DeviceState, *http.Response, error)) *MockIoTManagerManagementAPIAPI_IoTManagerManagementGetDeviceStatesExecute_Call {
	_c.Call.Return(run)
	return _c
}

// IoTManagerManagementListEvents provides a mock function for the type MockIoTManagerManagementAPIAPI
func (_mock *MockIoTManagerManagementAPIAPI) IoTManagerManagementListEvents(ctx context.Context) client.ApiIoTManagerManagementListEventsRequest {
	ret := _mock.Called(ctx)

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

	var r0 client.ApiIoTManagerManagementListEventsRequest
	if returnFunc, ok := ret.Get(0).(func(context.Context) client.ApiIoTManagerManagementListEventsRequest); ok {
		r0 = returnFunc(ctx)
	} else {
		r0 = ret.Get(0).(client.ApiIoTManagerManagementListEventsRequest)
	}
	return r0
}

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

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

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

func (_c *MockIoTManagerManagementAPIAPI_IoTManagerManagementListEvents_Call) Return(apiIoTManagerManagementListEventsRequest client.ApiIoTManagerManagementListEventsRequest) *MockIoTManagerManagementAPIAPI_IoTManagerManagementListEvents_Call {
	_c.Call.Return(apiIoTManagerManagementListEventsRequest)
	return _c
}

func (_c *MockIoTManagerManagementAPIAPI_IoTManagerManagementListEvents_Call) RunAndReturn(run func(ctx context.Context) client.ApiIoTManagerManagementListEventsRequest) *MockIoTManagerManagementAPIAPI_IoTManagerManagementListEvents_Call {
	_c.Call.Return(run)
	return _c
}

// IoTManagerManagementListEventsExecute provides a mock function for the type MockIoTManagerManagementAPIAPI
func (_mock *MockIoTManagerManagementAPIAPI) IoTManagerManagementListEventsExecute(r client.ApiIoTManagerManagementListEventsRequest) ([]client.Event, *http.Response, error) {
	ret := _mock.Called(r)

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

	var r0 []client.Event
	var r1 *http.Response
	var r2 error
	if returnFunc, ok := ret.Get(0).(func(client.ApiIoTManagerManagementListEventsRequest) ([]client.Event, *http.Response, error)); ok {
		return returnFunc(r)
	}
	if returnFunc, ok := ret.Get(0).(func(client.ApiIoTManagerManagementListEventsRequest) []client.Event); ok {
		r0 = returnFunc(r)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]client.Event)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(client.ApiIoTManagerManagementListEventsRequest) *http.Response); ok {
		r1 = returnFunc(r)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*http.Response)
		}
	}
	if returnFunc, ok := ret.Get(2).(func(client.ApiIoTManagerManagementListEventsRequest) error); ok {
		r2 = returnFunc(r)
	} else {
		r2 = ret.Error(2)
	}
	return r0, r1, r2
}

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

// IoTManagerManagementListEventsExecute is a helper method to define mock.On call
//   - r client.ApiIoTManagerManagementListEventsRequest
func (_e *MockIoTManagerManagementAPIAPI_Expecter) IoTManagerManagementListEventsExecute(r interface{}) *MockIoTManagerManagementAPIAPI_IoTManagerManagementListEventsExecute_Call {
	return &MockIoTManagerManagementAPIAPI_IoTManagerManagementListEventsExecute_Call{Call: _e.mock.On("IoTManagerManagementListEventsExecute", r)}
}

func (_c *MockIoTManagerManagementAPIAPI_IoTManagerManagementListEventsExecute_Call) Run(run func(r client.ApiIoTManagerManagementListEventsRequest)) *MockIoTManagerManagementAPIAPI_IoTManagerManagementListEventsExecute_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 client.ApiIoTManagerManagementListEventsRequest
		if args[0] != nil {
			arg0 = args[0].(client.ApiIoTManagerManagementListEventsRequest)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *MockIoTManagerManagementAPIAPI_IoTManagerManagementListEventsExecute_Call) Return(events []client.Event, response *http.Response, err error) *MockIoTManagerManagementAPIAPI_IoTManagerManagementListEventsExecute_Call {
	_c.Call.Return(events, response, err)
	return _c
}

func (_c *MockIoTManagerManagementAPIAPI_IoTManagerManagementListEventsExecute_Call) RunAndReturn(run func(r client.ApiIoTManagerManagementListEventsRequest) ([]client.Event, *http.Response, error)) *MockIoTManagerManagementAPIAPI_IoTManagerManagementListEventsExecute_Call {
	_c.Call.Return(run)
	return _c
}

// IoTManagerManagementListIntegrations provides a mock function for the type MockIoTManagerManagementAPIAPI
func (_mock *MockIoTManagerManagementAPIAPI) IoTManagerManagementListIntegrations(ctx context.Context) client.ApiIoTManagerManagementListIntegrationsRequest {
	ret := _mock.Called(ctx)

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

	var r0 client.ApiIoTManagerManagementListIntegrationsRequest
	if returnFunc, ok := ret.Get(0).(func(context.Context) client.ApiIoTManagerManagementListIntegrationsRequest); ok {
		r0 = returnFunc(ctx)
	} else {
		r0 = ret.Get(0).(client.ApiIoTManagerManagementListIntegrationsRequest)
	}
	return r0
}

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

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

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

func (_c *MockIoTManagerManagementAPIAPI_IoTManagerManagementListIntegrations_Call) Return(apiIoTManagerManagementListIntegrationsRequest client.ApiIoTManagerManagementListIntegrationsRequest) *MockIoTManagerManagementAPIAPI_IoTManagerManagementListIntegrations_Call {
	_c.Call.Return(apiIoTManagerManagementListIntegrationsRequest)
	return _c
}

func (_c *MockIoTManagerManagementAPIAPI_IoTManagerManagementListIntegrations_Call) RunAndReturn(run func(ctx context.Context) client.ApiIoTManagerManagementListIntegrationsRequest) *MockIoTManagerManagementAPIAPI_IoTManagerManagementListIntegrations_Call {
	_c.Call.Return(run)
	return _c
}

// IoTManagerManagementListIntegrationsExecute provides a mock function for the type MockIoTManagerManagementAPIAPI
func (_mock *MockIoTManagerManagementAPIAPI) IoTManagerManagementListIntegrationsExecute(r client.ApiIoTManagerManagementListIntegrationsRequest) ([]client.Integration, *http.Response, error) {
	ret := _mock.Called(r)

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

	var r0 []client.Integration
	var r1 *http.Response
	var r2 error
	if returnFunc, ok := ret.Get(0).(func(client.ApiIoTManagerManagementListIntegrationsRequest) ([]client.Integration, *http.Response, error)); ok {
		return returnFunc(r)
	}
	if returnFunc, ok := ret.Get(0).(func(client.ApiIoTManagerManagementListIntegrationsRequest) []client.Integration); ok {
		r0 = returnFunc(r)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]client.Integration)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(client.ApiIoTManagerManagementListIntegrationsRequest) *http.Response); ok {
		r1 = returnFunc(r)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*http.Response)
		}
	}
	if returnFunc, ok := ret.Get(2).(func(client.ApiIoTManagerManagementListIntegrationsRequest) error); ok {
		r2 = returnFunc(r)
	} else {
		r2 = ret.Error(2)
	}
	return r0, r1, r2
}

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

// IoTManagerManagementListIntegrationsExecute is a helper method to define mock.On call
//   - r client.ApiIoTManagerManagementListIntegrationsRequest
func (_e *MockIoTManagerManagementAPIAPI_Expecter) IoTManagerManagementListIntegrationsExecute(r interface{}) *MockIoTManagerManagementAPIAPI_IoTManagerManagementListIntegrationsExecute_Call {
	return &MockIoTManagerManagementAPIAPI_IoTManagerManagementListIntegrationsExecute_Call{Call: _e.mock.On("IoTManagerManagementListIntegrationsExecute", r)}
}

func (_c *MockIoTManagerManagementAPIAPI_IoTManagerManagementListIntegrationsExecute_Call) Run(run func(r client.ApiIoTManagerManagementListIntegrationsRequest)) *MockIoTManagerManagementAPIAPI_IoTManagerManagementListIntegrationsExecute_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 client.ApiIoTManagerManagementListIntegrationsRequest
		if args[0] != nil {
			arg0 = args[0].(client.ApiIoTManagerManagementListIntegrationsRequest)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *MockIoTManagerManagementAPIAPI_IoTManagerManagementListIntegrationsExecute_Call) Return(integrations []client.Integration, response *http.Response, err error) *MockIoTManagerManagementAPIAPI_IoTManagerManagementListIntegrationsExecute_Call {
	_c.Call.Return(integrations, response, err)
	return _c
}

func (_c *MockIoTManagerManagementAPIAPI_IoTManagerManagementListIntegrationsExecute_Call) RunAndReturn(run func(r client.ApiIoTManagerManagementListIntegrationsRequest) ([]client.Integration, *http.Response, error)) *MockIoTManagerManagementAPIAPI_IoTManagerManagementListIntegrationsExecute_Call {
	_c.Call.Return(run)
	return _c
}

// IoTManagerManagementRegisterIntegration provides a mock function for the type MockIoTManagerManagementAPIAPI
func (_mock *MockIoTManagerManagementAPIAPI) IoTManagerManagementRegisterIntegration(ctx context.Context) client.ApiIoTManagerManagementRegisterIntegrationRequest {
	ret := _mock.Called(ctx)

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

	var r0 client.ApiIoTManagerManagementRegisterIntegrationRequest
	if returnFunc, ok := ret.Get(0).(func(context.Context) client.ApiIoTManagerManagementRegisterIntegrationRequest); ok {
		r0 = returnFunc(ctx)
	} else {
		r0 = ret.Get(0).(client.ApiIoTManagerManagementRegisterIntegrationRequest)
	}
	return r0
}

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

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

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

func (_c *MockIoTManagerManagementAPIAPI_IoTManagerManagementRegisterIntegration_Call) Return(apiIoTManagerManagementRegisterIntegrationRequest client.ApiIoTManagerManagementRegisterIntegrationRequest) *MockIoTManagerManagementAPIAPI_IoTManagerManagementRegisterIntegration_Call {
	_c.Call.Return(apiIoTManagerManagementRegisterIntegrationRequest)
	return _c
}

func (_c *MockIoTManagerManagementAPIAPI_IoTManagerManagementRegisterIntegration_Call) RunAndReturn(run func(ctx context.Context) client.ApiIoTManagerManagementRegisterIntegrationRequest) *MockIoTManagerManagementAPIAPI_IoTManagerManagementRegisterIntegration_Call {
	_c.Call.Return(run)
	return _c
}

// IoTManagerManagementRegisterIntegrationExecute provides a mock function for the type MockIoTManagerManagementAPIAPI
func (_mock *MockIoTManagerManagementAPIAPI) IoTManagerManagementRegisterIntegrationExecute(r client.ApiIoTManagerManagementRegisterIntegrationRequest) (*http.Response, error) {
	ret := _mock.Called(r)

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

	var r0 *http.Response
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(client.ApiIoTManagerManagementRegisterIntegrationRequest) (*http.Response, error)); ok {
		return returnFunc(r)
	}
	if returnFunc, ok := ret.Get(0).(func(client.ApiIoTManagerManagementRegisterIntegrationRequest) *http.Response); ok {
		r0 = returnFunc(r)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*http.Response)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(client.ApiIoTManagerManagementRegisterIntegrationRequest) error); ok {
		r1 = returnFunc(r)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// IoTManagerManagementRegisterIntegrationExecute is a helper method to define mock.On call
//   - r client.ApiIoTManagerManagementRegisterIntegrationRequest
func (_e *MockIoTManagerManagementAPIAPI_Expecter) IoTManagerManagementRegisterIntegrationExecute(r interface{}) *MockIoTManagerManagementAPIAPI_IoTManagerManagementRegisterIntegrationExecute_Call {
	return &MockIoTManagerManagementAPIAPI_IoTManagerManagementRegisterIntegrationExecute_Call{Call: _e.mock.On("IoTManagerManagementRegisterIntegrationExecute", r)}
}

func (_c *MockIoTManagerManagementAPIAPI_IoTManagerManagementRegisterIntegrationExecute_Call) Run(run func(r client.ApiIoTManagerManagementRegisterIntegrationRequest)) *MockIoTManagerManagementAPIAPI_IoTManagerManagementRegisterIntegrationExecute_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 client.ApiIoTManagerManagementRegisterIntegrationRequest
		if args[0] != nil {
			arg0 = args[0].(client.ApiIoTManagerManagementRegisterIntegrationRequest)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *MockIoTManagerManagementAPIAPI_IoTManagerManagementRegisterIntegrationExecute_Call) Return(response *http.Response, err error) *MockIoTManagerManagementAPIAPI_IoTManagerManagementRegisterIntegrationExecute_Call {
	_c.Call.Return(response, err)
	return _c
}

func (_c *MockIoTManagerManagementAPIAPI_IoTManagerManagementRegisterIntegrationExecute_Call) RunAndReturn(run func(r client.ApiIoTManagerManagementRegisterIntegrationRequest) (*http.Response, error)) *MockIoTManagerManagementAPIAPI_IoTManagerManagementRegisterIntegrationExecute_Call {
	_c.Call.Return(run)
	return _c
}

// IoTManagerManagementRemoveIntegration provides a mock function for the type MockIoTManagerManagementAPIAPI
func (_mock *MockIoTManagerManagementAPIAPI) IoTManagerManagementRemoveIntegration(ctx context.Context, id string) client.ApiIoTManagerManagementRemoveIntegrationRequest {
	ret := _mock.Called(ctx, id)

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

	var r0 client.ApiIoTManagerManagementRemoveIntegrationRequest
	if returnFunc, ok := ret.Get(0).(func(context.Context, string) client.ApiIoTManagerManagementRemoveIntegrationRequest); ok {
		r0 = returnFunc(ctx, id)
	} else {
		r0 = ret.Get(0).(client.ApiIoTManagerManagementRemoveIntegrationRequest)
	}
	return r0
}

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

// IoTManagerManagementRemoveIntegration is a helper method to define mock.On call
//   - ctx context.Context
//   - id string
func (_e *MockIoTManagerManagementAPIAPI_Expecter) IoTManagerManagementRemoveIntegration(ctx interface{}, id interface{}) *MockIoTManagerManagementAPIAPI_IoTManagerManagementRemoveIntegration_Call {
	return &MockIoTManagerManagementAPIAPI_IoTManagerManagementRemoveIntegration_Call{Call: _e.mock.On("IoTManagerManagementRemoveIntegration", ctx, id)}
}

func (_c *MockIoTManagerManagementAPIAPI_IoTManagerManagementRemoveIntegration_Call) Run(run func(ctx context.Context, id string)) *MockIoTManagerManagementAPIAPI_IoTManagerManagementRemoveIntegration_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 *MockIoTManagerManagementAPIAPI_IoTManagerManagementRemoveIntegration_Call) Return(apiIoTManagerManagementRemoveIntegrationRequest client.ApiIoTManagerManagementRemoveIntegrationRequest) *MockIoTManagerManagementAPIAPI_IoTManagerManagementRemoveIntegration_Call {
	_c.Call.Return(apiIoTManagerManagementRemoveIntegrationRequest)
	return _c
}

func (_c *MockIoTManagerManagementAPIAPI_IoTManagerManagementRemoveIntegration_Call) RunAndReturn(run func(ctx context.Context, id string) client.ApiIoTManagerManagementRemoveIntegrationRequest) *MockIoTManagerManagementAPIAPI_IoTManagerManagementRemoveIntegration_Call {
	_c.Call.Return(run)
	return _c
}

// IoTManagerManagementRemoveIntegrationExecute provides a mock function for the type MockIoTManagerManagementAPIAPI
func (_mock *MockIoTManagerManagementAPIAPI) IoTManagerManagementRemoveIntegrationExecute(r client.ApiIoTManagerManagementRemoveIntegrationRequest) (*http.Response, error) {
	ret := _mock.Called(r)

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

	var r0 *http.Response
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(client.ApiIoTManagerManagementRemoveIntegrationRequest) (*http.Response, error)); ok {
		return returnFunc(r)
	}
	if returnFunc, ok := ret.Get(0).(func(client.ApiIoTManagerManagementRemoveIntegrationRequest) *http.Response); ok {
		r0 = returnFunc(r)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*http.Response)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(client.ApiIoTManagerManagementRemoveIntegrationRequest) error); ok {
		r1 = returnFunc(r)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// IoTManagerManagementRemoveIntegrationExecute is a helper method to define mock.On call
//   - r client.ApiIoTManagerManagementRemoveIntegrationRequest
func (_e *MockIoTManagerManagementAPIAPI_Expecter) IoTManagerManagementRemoveIntegrationExecute(r interface{}) *MockIoTManagerManagementAPIAPI_IoTManagerManagementRemoveIntegrationExecute_Call {
	return &MockIoTManagerManagementAPIAPI_IoTManagerManagementRemoveIntegrationExecute_Call{Call: _e.mock.On("IoTManagerManagementRemoveIntegrationExecute", r)}
}

func (_c *MockIoTManagerManagementAPIAPI_IoTManagerManagementRemoveIntegrationExecute_Call) Run(run func(r client.ApiIoTManagerManagementRemoveIntegrationRequest)) *MockIoTManagerManagementAPIAPI_IoTManagerManagementRemoveIntegrationExecute_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 client.ApiIoTManagerManagementRemoveIntegrationRequest
		if args[0] != nil {
			arg0 = args[0].(client.ApiIoTManagerManagementRemoveIntegrationRequest)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *MockIoTManagerManagementAPIAPI_IoTManagerManagementRemoveIntegrationExecute_Call) Return(response *http.Response, err error) *MockIoTManagerManagementAPIAPI_IoTManagerManagementRemoveIntegrationExecute_Call {
	_c.Call.Return(response, err)
	return _c
}

func (_c *MockIoTManagerManagementAPIAPI_IoTManagerManagementRemoveIntegrationExecute_Call) RunAndReturn(run func(r client.ApiIoTManagerManagementRemoveIntegrationRequest) (*http.Response, error)) *MockIoTManagerManagementAPIAPI_IoTManagerManagementRemoveIntegrationExecute_Call {
	_c.Call.Return(run)
	return _c
}

// IoTManagerManagementReplaceState provides a mock function for the type MockIoTManagerManagementAPIAPI
func (_mock *MockIoTManagerManagementAPIAPI) IoTManagerManagementReplaceState(ctx context.Context, deviceId string, integrationId string) client.ApiIoTManagerManagementReplaceStateRequest {
	ret := _mock.Called(ctx, deviceId, integrationId)

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

	var r0 client.ApiIoTManagerManagementReplaceStateRequest
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string) client.ApiIoTManagerManagementReplaceStateRequest); ok {
		r0 = returnFunc(ctx, deviceId, integrationId)
	} else {
		r0 = ret.Get(0).(client.ApiIoTManagerManagementReplaceStateRequest)
	}
	return r0
}

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

// IoTManagerManagementReplaceState is a helper method to define mock.On call
//   - ctx context.Context
//   - deviceId string
//   - integrationId string
func (_e *MockIoTManagerManagementAPIAPI_Expecter) IoTManagerManagementReplaceState(ctx interface{}, deviceId interface{}, integrationId interface{}) *MockIoTManagerManagementAPIAPI_IoTManagerManagementReplaceState_Call {
	return &MockIoTManagerManagementAPIAPI_IoTManagerManagementReplaceState_Call{Call: _e.mock.On("IoTManagerManagementReplaceState", ctx, deviceId, integrationId)}
}

func (_c *MockIoTManagerManagementAPIAPI_IoTManagerManagementReplaceState_Call) Run(run func(ctx context.Context, deviceId string, integrationId string)) *MockIoTManagerManagementAPIAPI_IoTManagerManagementReplaceState_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)
		}
		run(
			arg0,
			arg1,
			arg2,
		)
	})
	return _c
}

func (_c *MockIoTManagerManagementAPIAPI_IoTManagerManagementReplaceState_Call) Return(apiIoTManagerManagementReplaceStateRequest client.ApiIoTManagerManagementReplaceStateRequest) *MockIoTManagerManagementAPIAPI_IoTManagerManagementReplaceState_Call {
	_c.Call.Return(apiIoTManagerManagementReplaceStateRequest)
	return _c
}

func (_c *MockIoTManagerManagementAPIAPI_IoTManagerManagementReplaceState_Call) RunAndReturn(run func(ctx context.Context, deviceId string, integrationId string) client.ApiIoTManagerManagementReplaceStateRequest) *MockIoTManagerManagementAPIAPI_IoTManagerManagementReplaceState_Call {
	_c.Call.Return(run)
	return _c
}

// IoTManagerManagementReplaceStateExecute provides a mock function for the type MockIoTManagerManagementAPIAPI
func (_mock *MockIoTManagerManagementAPIAPI) IoTManagerManagementReplaceStateExecute(r client.ApiIoTManagerManagementReplaceStateRequest) (*client.DeviceState, *http.Response, error) {
	ret := _mock.Called(r)

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

	var r0 *client.DeviceState
	var r1 *http.Response
	var r2 error
	if returnFunc, ok := ret.Get(0).(func(client.ApiIoTManagerManagementReplaceStateRequest) (*client.DeviceState, *http.Response, error)); ok {
		return returnFunc(r)
	}
	if returnFunc, ok := ret.Get(0).(func(client.ApiIoTManagerManagementReplaceStateRequest) *client.DeviceState); ok {
		r0 = returnFunc(r)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*client.DeviceState)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(client.ApiIoTManagerManagementReplaceStateRequest) *http.Response); ok {
		r1 = returnFunc(r)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*http.Response)
		}
	}
	if returnFunc, ok := ret.Get(2).(func(client.ApiIoTManagerManagementReplaceStateRequest) error); ok {
		r2 = returnFunc(r)
	} else {
		r2 = ret.Error(2)
	}
	return r0, r1, r2
}

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

// IoTManagerManagementReplaceStateExecute is a helper method to define mock.On call
//   - r client.ApiIoTManagerManagementReplaceStateRequest
func (_e *MockIoTManagerManagementAPIAPI_Expecter) IoTManagerManagementReplaceStateExecute(r interface{}) *MockIoTManagerManagementAPIAPI_IoTManagerManagementReplaceStateExecute_Call {
	return &MockIoTManagerManagementAPIAPI_IoTManagerManagementReplaceStateExecute_Call{Call: _e.mock.On("IoTManagerManagementReplaceStateExecute", r)}
}

func (_c *MockIoTManagerManagementAPIAPI_IoTManagerManagementReplaceStateExecute_Call) Run(run func(r client.ApiIoTManagerManagementReplaceStateRequest)) *MockIoTManagerManagementAPIAPI_IoTManagerManagementReplaceStateExecute_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 client.ApiIoTManagerManagementReplaceStateRequest
		if args[0] != nil {
			arg0 = args[0].(client.ApiIoTManagerManagementReplaceStateRequest)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *MockIoTManagerManagementAPIAPI_IoTManagerManagementReplaceStateExecute_Call) Return(deviceState *client.DeviceState, response *http.Response, err error) *MockIoTManagerManagementAPIAPI_IoTManagerManagementReplaceStateExecute_Call {
	_c.Call.Return(deviceState, response, err)
	return _c
}

func (_c *MockIoTManagerManagementAPIAPI_IoTManagerManagementReplaceStateExecute_Call) RunAndReturn(run func(r client.ApiIoTManagerManagementReplaceStateRequest) (*client.DeviceState, *http.Response, error)) *MockIoTManagerManagementAPIAPI_IoTManagerManagementReplaceStateExecute_Call {
	_c.Call.Return(run)
	return _c
}

// IoTManagerManagementSetIntegrationCredentials provides a mock function for the type MockIoTManagerManagementAPIAPI
func (_mock *MockIoTManagerManagementAPIAPI) IoTManagerManagementSetIntegrationCredentials(ctx context.Context, id string) client.ApiIoTManagerManagementSetIntegrationCredentialsRequest {
	ret := _mock.Called(ctx, id)

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

	var r0 client.ApiIoTManagerManagementSetIntegrationCredentialsRequest
	if returnFunc, ok := ret.Get(0).(func(context.Context, string) client.ApiIoTManagerManagementSetIntegrationCredentialsRequest); ok {
		r0 = returnFunc(ctx, id)
	} else {
		r0 = ret.Get(0).(client.ApiIoTManagerManagementSetIntegrationCredentialsRequest)
	}
	return r0
}

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

// IoTManagerManagementSetIntegrationCredentials is a helper method to define mock.On call
//   - ctx context.Context
//   - id string
func (_e *MockIoTManagerManagementAPIAPI_Expecter) IoTManagerManagementSetIntegrationCredentials(ctx interface{}, id interface{}) *MockIoTManagerManagementAPIAPI_IoTManagerManagementSetIntegrationCredentials_Call {
	return &MockIoTManagerManagementAPIAPI_IoTManagerManagementSetIntegrationCredentials_Call{Call: _e.mock.On("IoTManagerManagementSetIntegrationCredentials", ctx, id)}
}

func (_c *MockIoTManagerManagementAPIAPI_IoTManagerManagementSetIntegrationCredentials_Call) Run(run func(ctx context.Context, id string)) *MockIoTManagerManagementAPIAPI_IoTManagerManagementSetIntegrationCredentials_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 *MockIoTManagerManagementAPIAPI_IoTManagerManagementSetIntegrationCredentials_Call) Return(apiIoTManagerManagementSetIntegrationCredentialsRequest client.ApiIoTManagerManagementSetIntegrationCredentialsRequest) *MockIoTManagerManagementAPIAPI_IoTManagerManagementSetIntegrationCredentials_Call {
	_c.Call.Return(apiIoTManagerManagementSetIntegrationCredentialsRequest)
	return _c
}

func (_c *MockIoTManagerManagementAPIAPI_IoTManagerManagementSetIntegrationCredentials_Call) RunAndReturn(run func(ctx context.Context, id string) client.ApiIoTManagerManagementSetIntegrationCredentialsRequest) *MockIoTManagerManagementAPIAPI_IoTManagerManagementSetIntegrationCredentials_Call {
	_c.Call.Return(run)
	return _c
}

// IoTManagerManagementSetIntegrationCredentialsExecute provides a mock function for the type MockIoTManagerManagementAPIAPI
func (_mock *MockIoTManagerManagementAPIAPI) IoTManagerManagementSetIntegrationCredentialsExecute(r client.ApiIoTManagerManagementSetIntegrationCredentialsRequest) (*http.Response, error) {
	ret := _mock.Called(r)

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

	var r0 *http.Response
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(client.ApiIoTManagerManagementSetIntegrationCredentialsRequest) (*http.Response, error)); ok {
		return returnFunc(r)
	}
	if returnFunc, ok := ret.Get(0).(func(client.ApiIoTManagerManagementSetIntegrationCredentialsRequest) *http.Response); ok {
		r0 = returnFunc(r)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*http.Response)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(client.ApiIoTManagerManagementSetIntegrationCredentialsRequest) error); ok {
		r1 = returnFunc(r)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// IoTManagerManagementSetIntegrationCredentialsExecute is a helper method to define mock.On call
//   - r client.ApiIoTManagerManagementSetIntegrationCredentialsRequest
func (_e *MockIoTManagerManagementAPIAPI_Expecter) IoTManagerManagementSetIntegrationCredentialsExecute(r interface{}) *MockIoTManagerManagementAPIAPI_IoTManagerManagementSetIntegrationCredentialsExecute_Call {
	return &MockIoTManagerManagementAPIAPI_IoTManagerManagementSetIntegrationCredentialsExecute_Call{Call: _e.mock.On("IoTManagerManagementSetIntegrationCredentialsExecute", r)}
}

func (_c *MockIoTManagerManagementAPIAPI_IoTManagerManagementSetIntegrationCredentialsExecute_Call) Run(run func(r client.ApiIoTManagerManagementSetIntegrationCredentialsRequest)) *MockIoTManagerManagementAPIAPI_IoTManagerManagementSetIntegrationCredentialsExecute_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 client.ApiIoTManagerManagementSetIntegrationCredentialsRequest
		if args[0] != nil {
			arg0 = args[0].(client.ApiIoTManagerManagementSetIntegrationCredentialsRequest)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *MockIoTManagerManagementAPIAPI_IoTManagerManagementSetIntegrationCredentialsExecute_Call) Return(response *http.Response, err error) *MockIoTManagerManagementAPIAPI_IoTManagerManagementSetIntegrationCredentialsExecute_Call {
	_c.Call.Return(response, err)
	return _c
}

func (_c *MockIoTManagerManagementAPIAPI_IoTManagerManagementSetIntegrationCredentialsExecute_Call) RunAndReturn(run func(r client.ApiIoTManagerManagementSetIntegrationCredentialsRequest) (*http.Response, error)) *MockIoTManagerManagementAPIAPI_IoTManagerManagementSetIntegrationCredentialsExecute_Call {
	_c.Call.Return(run)
	return _c
}

// IoTManagerManagementUnregisterDeviceIntegrations provides a mock function for the type MockIoTManagerManagementAPIAPI
func (_mock *MockIoTManagerManagementAPIAPI) IoTManagerManagementUnregisterDeviceIntegrations(ctx context.Context, deviceId string) client.ApiIoTManagerManagementUnregisterDeviceIntegrationsRequest {
	ret := _mock.Called(ctx, deviceId)

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

	var r0 client.ApiIoTManagerManagementUnregisterDeviceIntegrationsRequest
	if returnFunc, ok := ret.Get(0).(func(context.Context, string) client.ApiIoTManagerManagementUnregisterDeviceIntegrationsRequest); ok {
		r0 = returnFunc(ctx, deviceId)
	} else {
		r0 = ret.Get(0).(client.ApiIoTManagerManagementUnregisterDeviceIntegrationsRequest)
	}
	return r0
}

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

// IoTManagerManagementUnregisterDeviceIntegrations is a helper method to define mock.On call
//   - ctx context.Context
//   - deviceId string
func (_e *MockIoTManagerManagementAPIAPI_Expecter) IoTManagerManagementUnregisterDeviceIntegrations(ctx interface{}, deviceId interface{}) *MockIoTManagerManagementAPIAPI_IoTManagerManagementUnregisterDeviceIntegrations_Call {
	return &MockIoTManagerManagementAPIAPI_IoTManagerManagementUnregisterDeviceIntegrations_Call{Call: _e.mock.On("IoTManagerManagementUnregisterDeviceIntegrations", ctx, deviceId)}
}

func (_c *MockIoTManagerManagementAPIAPI_IoTManagerManagementUnregisterDeviceIntegrations_Call) Run(run func(ctx context.Context, deviceId string)) *MockIoTManagerManagementAPIAPI_IoTManagerManagementUnregisterDeviceIntegrations_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 *MockIoTManagerManagementAPIAPI_IoTManagerManagementUnregisterDeviceIntegrations_Call) Return(apiIoTManagerManagementUnregisterDeviceIntegrationsRequest client.ApiIoTManagerManagementUnregisterDeviceIntegrationsRequest) *MockIoTManagerManagementAPIAPI_IoTManagerManagementUnregisterDeviceIntegrations_Call {
	_c.Call.Return(apiIoTManagerManagementUnregisterDeviceIntegrationsRequest)
	return _c
}

func (_c *MockIoTManagerManagementAPIAPI_IoTManagerManagementUnregisterDeviceIntegrations_Call) RunAndReturn(run func(ctx context.Context, deviceId string) client.ApiIoTManagerManagementUnregisterDeviceIntegrationsRequest) *MockIoTManagerManagementAPIAPI_IoTManagerManagementUnregisterDeviceIntegrations_Call {
	_c.Call.Return(run)
	return _c
}

// IoTManagerManagementUnregisterDeviceIntegrationsExecute provides a mock function for the type MockIoTManagerManagementAPIAPI
func (_mock *MockIoTManagerManagementAPIAPI) IoTManagerManagementUnregisterDeviceIntegrationsExecute(r client.ApiIoTManagerManagementUnregisterDeviceIntegrationsRequest) (*client.DeviceState, *http.Response, error) {
	ret := _mock.Called(r)

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

	var r0 *client.DeviceState
	var r1 *http.Response
	var r2 error
	if returnFunc, ok := ret.Get(0).(func(client.ApiIoTManagerManagementUnregisterDeviceIntegrationsRequest) (*client.DeviceState, *http.Response, error)); ok {
		return returnFunc(r)
	}
	if returnFunc, ok := ret.Get(0).(func(client.ApiIoTManagerManagementUnregisterDeviceIntegrationsRequest) *client.DeviceState); ok {
		r0 = returnFunc(r)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*client.DeviceState)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(client.ApiIoTManagerManagementUnregisterDeviceIntegrationsRequest) *http.Response); ok {
		r1 = returnFunc(r)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*http.Response)
		}
	}
	if returnFunc, ok := ret.Get(2).(func(client.ApiIoTManagerManagementUnregisterDeviceIntegrationsRequest) error); ok {
		r2 = returnFunc(r)
	} else {
		r2 = ret.Error(2)
	}
	return r0, r1, r2
}

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

// IoTManagerManagementUnregisterDeviceIntegrationsExecute is a helper method to define mock.On call
//   - r client.ApiIoTManagerManagementUnregisterDeviceIntegrationsRequest
func (_e *MockIoTManagerManagementAPIAPI_Expecter) IoTManagerManagementUnregisterDeviceIntegrationsExecute(r interface{}) *MockIoTManagerManagementAPIAPI_IoTManagerManagementUnregisterDeviceIntegrationsExecute_Call {
	return &MockIoTManagerManagementAPIAPI_IoTManagerManagementUnregisterDeviceIntegrationsExecute_Call{Call: _e.mock.On("IoTManagerManagementUnregisterDeviceIntegrationsExecute", r)}
}

func (_c *MockIoTManagerManagementAPIAPI_IoTManagerManagementUnregisterDeviceIntegrationsExecute_Call) Run(run func(r client.ApiIoTManagerManagementUnregisterDeviceIntegrationsRequest)) *MockIoTManagerManagementAPIAPI_IoTManagerManagementUnregisterDeviceIntegrationsExecute_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 client.ApiIoTManagerManagementUnregisterDeviceIntegrationsRequest
		if args[0] != nil {
			arg0 = args[0].(client.ApiIoTManagerManagementUnregisterDeviceIntegrationsRequest)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *MockIoTManagerManagementAPIAPI_IoTManagerManagementUnregisterDeviceIntegrationsExecute_Call) Return(deviceState *client.DeviceState, response *http.Response, err error) *MockIoTManagerManagementAPIAPI_IoTManagerManagementUnregisterDeviceIntegrationsExecute_Call {
	_c.Call.Return(deviceState, response, err)
	return _c
}

func (_c *MockIoTManagerManagementAPIAPI_IoTManagerManagementUnregisterDeviceIntegrationsExecute_Call) RunAndReturn(run func(r client.ApiIoTManagerManagementUnregisterDeviceIntegrationsRequest) (*client.DeviceState, *http.Response, error)) *MockIoTManagerManagementAPIAPI_IoTManagerManagementUnregisterDeviceIntegrationsExecute_Call {
	_c.Call.Return(run)
	return _c
}

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

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

	return mock
}

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

type MockUserAdministrationAndAuthenticationInternalAPIAPI_Expecter struct {
	mock *mock.Mock
}

func (_m *MockUserAdministrationAndAuthenticationInternalAPIAPI) EXPECT() *MockUserAdministrationAndAuthenticationInternalAPIAPI_Expecter {
	return &MockUserAdministrationAndAuthenticationInternalAPIAPI_Expecter{mock: &_m.Mock}
}

// CreateUserInternal provides a mock function for the type MockUserAdministrationAndAuthenticationInternalAPIAPI
func (_mock *MockUserAdministrationAndAuthenticationInternalAPIAPI) CreateUserInternal(ctx context.Context, tenantId string) client.ApiCreateUserInternalRequest {
	ret := _mock.Called(ctx, tenantId)

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

	var r0 client.ApiCreateUserInternalRequest
	if returnFunc, ok := ret.Get(0).(func(context.Context, string) client.ApiCreateUserInternalRequest); ok {
		r0 = returnFunc(ctx, tenantId)
	} else {
		r0 = ret.Get(0).(client.ApiCreateUserInternalRequest)
	}
	return r0
}

// MockUserAdministrationAndAuthenticationInternalAPIAPI_CreateUserInternal_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateUserInternal'
type MockUserAdministrationAndAuthenticationInternalAPIAPI_CreateUserInternal_Call struct {
	*mock.Call
}

// CreateUserInternal is a helper method to define mock.On call
//   - ctx context.Context
//   - tenantId string
func (_e *MockUserAdministrationAndAuthenticationInternalAPIAPI_Expecter) CreateUserInternal(ctx interface{}, tenantId interface{}) *MockUserAdministrationAndAuthenticationInternalAPIAPI_CreateUserInternal_Call {
	return &MockUserAdministrationAndAuthenticationInternalAPIAPI_CreateUserInternal_Call{Call: _e.mock.On("CreateUserInternal", ctx, tenantId)}
}

func (_c *MockUserAdministrationAndAuthenticationInternalAPIAPI_CreateUserInternal_Call) Run(run func(ctx context.Context, tenantId string)) *MockUserAdministrationAndAuthenticationInternalAPIAPI_CreateUserInternal_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 *MockUserAdministrationAndAuthenticationInternalAPIAPI_CreateUserInternal_Call) Return(apiCreateUserInternalRequest client.ApiCreateUserInternalRequest) *MockUserAdministrationAndAuthenticationInternalAPIAPI_CreateUserInternal_Call {
	_c.Call.Return(apiCreateUserInternalRequest)
	return _c
}

func (_c *MockUserAdministrationAndAuthenticationInternalAPIAPI_CreateUserInternal_Call) RunAndReturn(run func(ctx context.Context, tenantId string) client.ApiCreateUserInternalRequest) *MockUserAdministrationAndAuthenticationInternalAPIAPI_CreateUserInternal_Call {
	_c.Call.Return(run)
	return _c
}

// CreateUserInternalExecute provides a mock function for the type MockUserAdministrationAndAuthenticationInternalAPIAPI
func (_mock *MockUserAdministrationAndAuthenticationInternalAPIAPI) CreateUserInternalExecute(r client.ApiCreateUserInternalRequest) (*http.Response, error) {
	ret := _mock.Called(r)

	if len(ret) == 0 {
		panic("no return value specified for CreateUserInternalExecute")
	}

	var r0 *http.Response
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(client.ApiCreateUserInternalRequest) (*http.Response, error)); ok {
		return returnFunc(r)
	}
	if returnFunc, ok := ret.Get(0).(func(client.ApiCreateUserInternalRequest) *http.Response); ok {
		r0 = returnFunc(r)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*http.Response)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(client.ApiCreateUserInternalRequest) error); ok {
		r1 = returnFunc(r)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// MockUserAdministrationAndAuthenticationInternalAPIAPI_CreateUserInternalExecute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateUserInternalExecute'
type MockUserAdministrationAndAuthenticationInternalAPIAPI_CreateUserInternalExecute_Call struct {
	*mock.Call
}

// CreateUserInternalExecute is a helper method to define mock.On call
//   - r client.ApiCreateUserInternalRequest
func (_e *MockUserAdministrationAndAuthenticationInternalAPIAPI_Expecter) CreateUserInternalExecute(r interface{}) *MockUserAdministrationAndAuthenticationInternalAPIAPI_CreateUserInternalExecute_Call {
	return &MockUserAdministrationAndAuthenticationInternalAPIAPI_CreateUserInternalExecute_Call{Call: _e.mock.On("CreateUserInternalExecute", r)}
}

func (_c *MockUserAdministrationAndAuthenticationInternalAPIAPI_CreateUserInternalExecute_Call) Run(run func(r client.ApiCreateUserInternalRequest)) *MockUserAdministrationAndAuthenticationInternalAPIAPI_CreateUserInternalExecute_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 client.ApiCreateUserInternalRequest
		if args[0] != nil {
			arg0 = args[0].(client.ApiCreateUserInternalRequest)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *MockUserAdministrationAndAuthenticationInternalAPIAPI_CreateUserInternalExecute_Call) Return(response *http.Response, err error) *MockUserAdministrationAndAuthenticationInternalAPIAPI_CreateUserInternalExecute_Call {
	_c.Call.Return(response, err)
	return _c
}

func (_c *MockUserAdministrationAndAuthenticationInternalAPIAPI_CreateUserInternalExecute_Call) RunAndReturn(run func(r client.ApiCreateUserInternalRequest) (*http.Response, error)) *MockUserAdministrationAndAuthenticationInternalAPIAPI_CreateUserInternalExecute_Call {
	_c.Call.Return(run)
	return _c
}

// DeleteUserInternal provides a mock function for the type MockUserAdministrationAndAuthenticationInternalAPIAPI
func (_mock *MockUserAdministrationAndAuthenticationInternalAPIAPI) DeleteUserInternal(ctx context.Context, tenantId string, userId string) client.ApiDeleteUserInternalRequest {
	ret := _mock.Called(ctx, tenantId, userId)

	if len(ret) == 0 {
		panic("no return value specified for DeleteUserInternal")
	}

	var r0 client.ApiDeleteUserInternalRequest
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string) client.ApiDeleteUserInternalRequest); ok {
		r0 = returnFunc(ctx, tenantId, userId)
	} else {
		r0 = ret.Get(0).(client.ApiDeleteUserInternalRequest)
	}
	return r0
}

// MockUserAdministrationAndAuthenticationInternalAPIAPI_DeleteUserInternal_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteUserInternal'
type MockUserAdministrationAndAuthenticationInternalAPIAPI_DeleteUserInternal_Call struct {
	*mock.Call
}

// DeleteUserInternal is a helper method to define mock.On call
//   - ctx context.Context
//   - tenantId string
//   - userId string
func (_e *MockUserAdministrationAndAuthenticationInternalAPIAPI_Expecter) DeleteUserInternal(ctx interface{}, tenantId interface{}, userId interface{}) *MockUserAdministrationAndAuthenticationInternalAPIAPI_DeleteUserInternal_Call {
	return &MockUserAdministrationAndAuthenticationInternalAPIAPI_DeleteUserInternal_Call{Call: _e.mock.On("DeleteUserInternal", ctx, tenantId, userId)}
}

func (_c *MockUserAdministrationAndAuthenticationInternalAPIAPI_DeleteUserInternal_Call) Run(run func(ctx context.Context, tenantId string, userId string)) *MockUserAdministrationAndAuthenticationInternalAPIAPI_DeleteUserInternal_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)
		}
		run(
			arg0,
			arg1,
			arg2,
		)
	})
	return _c
}

func (_c *MockUserAdministrationAndAuthenticationInternalAPIAPI_DeleteUserInternal_Call) Return(apiDeleteUserInternalRequest client.ApiDeleteUserInternalRequest) *MockUserAdministrationAndAuthenticationInternalAPIAPI_DeleteUserInternal_Call {
	_c.Call.Return(apiDeleteUserInternalRequest)
	return _c
}

func (_c *MockUserAdministrationAndAuthenticationInternalAPIAPI_DeleteUserInternal_Call) RunAndReturn(run func(ctx context.Context, tenantId string, userId string) client.ApiDeleteUserInternalRequest) *MockUserAdministrationAndAuthenticationInternalAPIAPI_DeleteUserInternal_Call {
	_c.Call.Return(run)
	return _c
}

// DeleteUserInternalExecute provides a mock function for the type MockUserAdministrationAndAuthenticationInternalAPIAPI
func (_mock *MockUserAdministrationAndAuthenticationInternalAPIAPI) DeleteUserInternalExecute(r client.ApiDeleteUserInternalRequest) (*http.Response, error) {
	ret := _mock.Called(r)

	if len(ret) == 0 {
		panic("no return value specified for DeleteUserInternalExecute")
	}

	var r0 *http.Response
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(client.ApiDeleteUserInternalRequest) (*http.Response, error)); ok {
		return returnFunc(r)
	}
	if returnFunc, ok := ret.Get(0).(func(client.ApiDeleteUserInternalRequest) *http.Response); ok {
		r0 = returnFunc(r)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*http.Response)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(client.ApiDeleteUserInternalRequest) error); ok {
		r1 = returnFunc(r)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// MockUserAdministrationAndAuthenticationInternalAPIAPI_DeleteUserInternalExecute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteUserInternalExecute'
type MockUserAdministrationAndAuthenticationInternalAPIAPI_DeleteUserInternalExecute_Call struct {
	*mock.Call
}

// DeleteUserInternalExecute is a helper method to define mock.On call
//   - r client.ApiDeleteUserInternalRequest
func (_e *MockUserAdministrationAndAuthenticationInternalAPIAPI_Expecter) DeleteUserInternalExecute(r interface{}) *MockUserAdministrationAndAuthenticationInternalAPIAPI_DeleteUserInternalExecute_Call {
	return &MockUserAdministrationAndAuthenticationInternalAPIAPI_DeleteUserInternalExecute_Call{Call: _e.mock.On("DeleteUserInternalExecute", r)}
}

func (_c *MockUserAdministrationAndAuthenticationInternalAPIAPI_DeleteUserInternalExecute_Call) Run(run func(r client.ApiDeleteUserInternalRequest)) *MockUserAdministrationAndAuthenticationInternalAPIAPI_DeleteUserInternalExecute_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 client.ApiDeleteUserInternalRequest
		if args[0] != nil {
			arg0 = args[0].(client.ApiDeleteUserInternalRequest)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *MockUserAdministrationAndAuthenticationInternalAPIAPI_DeleteUserInternalExecute_Call) Return(response *http.Response, err error) *MockUserAdministrationAndAuthenticationInternalAPIAPI_DeleteUserInternalExecute_Call {
	_c.Call.Return(response, err)
	return _c
}

func (_c *MockUserAdministrationAndAuthenticationInternalAPIAPI_DeleteUserInternalExecute_Call) RunAndReturn(run func(r client.ApiDeleteUserInternalRequest) (*http.Response, error)) *MockUserAdministrationAndAuthenticationInternalAPIAPI_DeleteUserInternalExecute_Call {
	_c.Call.Return(run)
	return _c
}

// ListUsersInternal provides a mock function for the type MockUserAdministrationAndAuthenticationInternalAPIAPI
func (_mock *MockUserAdministrationAndAuthenticationInternalAPIAPI) ListUsersInternal(ctx context.Context, tenantId string) client.ApiListUsersInternalRequest {
	ret := _mock.Called(ctx, tenantId)

	if len(ret) == 0 {
		panic("no return value specified for ListUsersInternal")
	}

	var r0 client.ApiListUsersInternalRequest
	if returnFunc, ok := ret.Get(0).(func(context.Context, string) client.ApiListUsersInternalRequest); ok {
		r0 = returnFunc(ctx, tenantId)
	} else {
		r0 = ret.Get(0).(client.ApiListUsersInternalRequest)
	}
	return r0
}

// MockUserAdministrationAndAuthenticationInternalAPIAPI_ListUsersInternal_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListUsersInternal'
type MockUserAdministrationAndAuthenticationInternalAPIAPI_ListUsersInternal_Call struct {
	*mock.Call
}

// ListUsersInternal is a helper method to define mock.On call
//   - ctx context.Context
//   - tenantId string
func (_e *MockUserAdministrationAndAuthenticationInternalAPIAPI_Expecter) ListUsersInternal(ctx interface{}, tenantId interface{}) *MockUserAdministrationAndAuthenticationInternalAPIAPI_ListUsersInternal_Call {
	return &MockUserAdministrationAndAuthenticationInternalAPIAPI_ListUsersInternal_Call{Call: _e.mock.On("ListUsersInternal", ctx, tenantId)}
}

func (_c *MockUserAdministrationAndAuthenticationInternalAPIAPI_ListUsersInternal_Call) Run(run func(ctx context.Context, tenantId string)) *MockUserAdministrationAndAuthenticationInternalAPIAPI_ListUsersInternal_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 *MockUserAdministrationAndAuthenticationInternalAPIAPI_ListUsersInternal_Call) Return(apiListUsersInternalRequest client.ApiListUsersInternalRequest) *MockUserAdministrationAndAuthenticationInternalAPIAPI_ListUsersInternal_Call {
	_c.Call.Return(apiListUsersInternalRequest)
	return _c
}

func (_c *MockUserAdministrationAndAuthenticationInternalAPIAPI_ListUsersInternal_Call) RunAndReturn(run func(ctx context.Context, tenantId string) client.ApiListUsersInternalRequest) *MockUserAdministrationAndAuthenticationInternalAPIAPI_ListUsersInternal_Call {
	_c.Call.Return(run)
	return _c
}

// ListUsersInternalExecute provides a mock function for the type MockUserAdministrationAndAuthenticationInternalAPIAPI
func (_mock *MockUserAdministrationAndAuthenticationInternalAPIAPI) ListUsersInternalExecute(r client.ApiListUsersInternalRequest) ([]client.User, *http.Response, error) {
	ret := _mock.Called(r)

	if len(ret) == 0 {
		panic("no return value specified for ListUsersInternalExecute")
	}

	var r0 []client.User
	var r1 *http.Response
	var r2 error
	if returnFunc, ok := ret.Get(0).(func(client.ApiListUsersInternalRequest) ([]client.User, *http.Response, error)); ok {
		return returnFunc(r)
	}
	if returnFunc, ok := ret.Get(0).(func(client.ApiListUsersInternalRequest) []client.User); ok {
		r0 = returnFunc(r)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]client.User)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(client.ApiListUsersInternalRequest) *http.Response); ok {
		r1 = returnFunc(r)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*http.Response)
		}
	}
	if returnFunc, ok := ret.Get(2).(func(client.ApiListUsersInternalRequest) error); ok {
		r2 = returnFunc(r)
	} else {
		r2 = ret.Error(2)
	}
	return r0, r1, r2
}

// MockUserAdministrationAndAuthenticationInternalAPIAPI_ListUsersInternalExecute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListUsersInternalExecute'
type MockUserAdministrationAndAuthenticationInternalAPIAPI_ListUsersInternalExecute_Call struct {
	*mock.Call
}

// ListUsersInternalExecute is a helper method to define mock.On call
//   - r client.ApiListUsersInternalRequest
func (_e *MockUserAdministrationAndAuthenticationInternalAPIAPI_Expecter) ListUsersInternalExecute(r interface{}) *MockUserAdministrationAndAuthenticationInternalAPIAPI_ListUsersInternalExecute_Call {
	return &MockUserAdministrationAndAuthenticationInternalAPIAPI_ListUsersInternalExecute_Call{Call: _e.mock.On("ListUsersInternalExecute", r)}
}

func (_c *MockUserAdministrationAndAuthenticationInternalAPIAPI_ListUsersInternalExecute_Call) Run(run func(r client.ApiListUsersInternalRequest)) *MockUserAdministrationAndAuthenticationInternalAPIAPI_ListUsersInternalExecute_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 client.ApiListUsersInternalRequest
		if args[0] != nil {
			arg0 = args[0].(client.ApiListUsersInternalRequest)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *MockUserAdministrationAndAuthenticationInternalAPIAPI_ListUsersInternalExecute_Call) Return(users []client.User, response *http.Response, err error) *MockUserAdministrationAndAuthenticationInternalAPIAPI_ListUsersInternalExecute_Call {
	_c.Call.Return(users, response, err)
	return _c
}

func (_c *MockUserAdministrationAndAuthenticationInternalAPIAPI_ListUsersInternalExecute_Call) RunAndReturn(run func(r client.ApiListUsersInternalRequest) ([]client.User, *http.Response, error)) *MockUserAdministrationAndAuthenticationInternalAPIAPI_ListUsersInternalExecute_Call {
	_c.Call.Return(run)
	return _c
}

// RevokeUserTokens provides a mock function for the type MockUserAdministrationAndAuthenticationInternalAPIAPI
func (_mock *MockUserAdministrationAndAuthenticationInternalAPIAPI) RevokeUserTokens(ctx context.Context) client.ApiRevokeUserTokensRequest {
	ret := _mock.Called(ctx)

	if len(ret) == 0 {
		panic("no return value specified for RevokeUserTokens")
	}

	var r0 client.ApiRevokeUserTokensRequest
	if returnFunc, ok := ret.Get(0).(func(context.Context) client.ApiRevokeUserTokensRequest); ok {
		r0 = returnFunc(ctx)
	} else {
		r0 = ret.Get(0).(client.ApiRevokeUserTokensRequest)
	}
	return r0
}

// MockUserAdministrationAndAuthenticationInternalAPIAPI_RevokeUserTokens_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RevokeUserTokens'
type MockUserAdministrationAndAuthenticationInternalAPIAPI_RevokeUserTokens_Call struct {
	*mock.Call
}

// RevokeUserTokens is a helper method to define mock.On call
//   - ctx context.Context
func (_e *MockUserAdministrationAndAuthenticationInternalAPIAPI_Expecter) RevokeUserTokens(ctx interface{}) *MockUserAdministrationAndAuthenticationInternalAPIAPI_RevokeUserTokens_Call {
	return &MockUserAdministrationAndAuthenticationInternalAPIAPI_RevokeUserTokens_Call{Call: _e.mock.On("RevokeUserTokens", ctx)}
}

func (_c *MockUserAdministrationAndAuthenticationInternalAPIAPI_RevokeUserTokens_Call) Run(run func(ctx context.Context)) *MockUserAdministrationAndAuthenticationInternalAPIAPI_RevokeUserTokens_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *MockUserAdministrationAndAuthenticationInternalAPIAPI_RevokeUserTokens_Call) Return(apiRevokeUserTokensRequest client.ApiRevokeUserTokensRequest) *MockUserAdministrationAndAuthenticationInternalAPIAPI_RevokeUserTokens_Call {
	_c.Call.Return(apiRevokeUserTokensRequest)
	return _c
}

func (_c *MockUserAdministrationAndAuthenticationInternalAPIAPI_RevokeUserTokens_Call) RunAndReturn(run func(ctx context.Context) client.ApiRevokeUserTokensRequest) *MockUserAdministrationAndAuthenticationInternalAPIAPI_RevokeUserTokens_Call {
	_c.Call.Return(run)
	return _c
}

// RevokeUserTokensExecute provides a mock function for the type MockUserAdministrationAndAuthenticationInternalAPIAPI
func (_mock *MockUserAdministrationAndAuthenticationInternalAPIAPI) RevokeUserTokensExecute(r client.ApiRevokeUserTokensRequest) (*http.Response, error) {
	ret := _mock.Called(r)

	if len(ret) == 0 {
		panic("no return value specified for RevokeUserTokensExecute")
	}

	var r0 *http.Response
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(client.ApiRevokeUserTokensRequest) (*http.Response, error)); ok {
		return returnFunc(r)
	}
	if returnFunc, ok := ret.Get(0).(func(client.ApiRevokeUserTokensRequest) *http.Response); ok {
		r0 = returnFunc(r)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*http.Response)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(client.ApiRevokeUserTokensRequest) error); ok {
		r1 = returnFunc(r)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// MockUserAdministrationAndAuthenticationInternalAPIAPI_RevokeUserTokensExecute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RevokeUserTokensExecute'
type MockUserAdministrationAndAuthenticationInternalAPIAPI_RevokeUserTokensExecute_Call struct {
	*mock.Call
}

// RevokeUserTokensExecute is a helper method to define mock.On call
//   - r client.ApiRevokeUserTokensRequest
func (_e *MockUserAdministrationAndAuthenticationInternalAPIAPI_Expecter) RevokeUserTokensExecute(r interface{}) *MockUserAdministrationAndAuthenticationInternalAPIAPI_RevokeUserTokensExecute_Call {
	return &MockUserAdministrationAndAuthenticationInternalAPIAPI_RevokeUserTokensExecute_Call{Call: _e.mock.On("RevokeUserTokensExecute", r)}
}

func (_c *MockUserAdministrationAndAuthenticationInternalAPIAPI_RevokeUserTokensExecute_Call) Run(run func(r client.ApiRevokeUserTokensRequest)) *MockUserAdministrationAndAuthenticationInternalAPIAPI_RevokeUserTokensExecute_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 client.ApiRevokeUserTokensRequest
		if args[0] != nil {
			arg0 = args[0].(client.ApiRevokeUserTokensRequest)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *MockUserAdministrationAndAuthenticationInternalAPIAPI_RevokeUserTokensExecute_Call) Return(response *http.Response, err error) *MockUserAdministrationAndAuthenticationInternalAPIAPI_RevokeUserTokensExecute_Call {
	_c.Call.Return(response, err)
	return _c
}

func (_c *MockUserAdministrationAndAuthenticationInternalAPIAPI_RevokeUserTokensExecute_Call) RunAndReturn(run func(r client.ApiRevokeUserTokensRequest) (*http.Response, error)) *MockUserAdministrationAndAuthenticationInternalAPIAPI_RevokeUserTokensExecute_Call {
	_c.Call.Return(run)
	return _c
}

// UseradmCheckHealth provides a mock function for the type MockUserAdministrationAndAuthenticationInternalAPIAPI
func (_mock *MockUserAdministrationAndAuthenticationInternalAPIAPI) UseradmCheckHealth(ctx context.Context) client.ApiUseradmCheckHealthRequest {
	ret := _mock.Called(ctx)

	if len(ret) == 0 {
		panic("no return value specified for UseradmCheckHealth")
	}

	var r0 client.ApiUseradmCheckHealthRequest
	if returnFunc, ok := ret.Get(0).(func(context.Context) client.ApiUseradmCheckHealthRequest); ok {
		r0 = returnFunc(ctx)
	} else {
		r0 = ret.Get(0).(client.ApiUseradmCheckHealthRequest)
	}
	return r0
}

// MockUserAdministrationAndAuthenticationInternalAPIAPI_UseradmCheckHealth_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UseradmCheckHealth'
type MockUserAdministrationAndAuthenticationInternalAPIAPI_UseradmCheckHealth_Call struct {
	*mock.Call
}

// UseradmCheckHealth is a helper method to define mock.On call
//   - ctx context.Context
func (_e *MockUserAdministrationAndAuthenticationInternalAPIAPI_Expecter) UseradmCheckHealth(ctx interface{}) *MockUserAdministrationAndAuthenticationInternalAPIAPI_UseradmCheckHealth_Call {
	return &MockUserAdministrationAndAuthenticationInternalAPIAPI_UseradmCheckHealth_Call{Call: _e.mock.On("UseradmCheckHealth", ctx)}
}

func (_c *MockUserAdministrationAndAuthenticationInternalAPIAPI_UseradmCheckHealth_Call) Run(run func(ctx context.Context)) *MockUserAdministrationAndAuthenticationInternalAPIAPI_UseradmCheckHealth_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *MockUserAdministrationAndAuthenticationInternalAPIAPI_UseradmCheckHealth_Call) Return(apiUseradmCheckHealthRequest client.ApiUseradmCheckHealthRequest) *MockUserAdministrationAndAuthenticationInternalAPIAPI_UseradmCheckHealth_Call {
	_c.Call.Return(apiUseradmCheckHealthRequest)
	return _c
}

func (_c *MockUserAdministrationAndAuthenticationInternalAPIAPI_UseradmCheckHealth_Call) RunAndReturn(run func(ctx context.Context) client.ApiUseradmCheckHealthRequest) *MockUserAdministrationAndAuthenticationInternalAPIAPI_UseradmCheckHealth_Call {
	_c.Call.Return(run)
	return _c
}

// UseradmCheckHealthExecute provides a mock function for the type MockUserAdministrationAndAuthenticationInternalAPIAPI
func (_mock *MockUserAdministrationAndAuthenticationInternalAPIAPI) UseradmCheckHealthExecute(r client.ApiUseradmCheckHealthRequest) (*http.Response, error) {
	ret := _mock.Called(r)

	if len(ret) == 0 {
		panic("no return value specified for UseradmCheckHealthExecute")
	}

	var r0 *http.Response
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(client.ApiUseradmCheckHealthRequest) (*http.Response, error)); ok {
		return returnFunc(r)
	}
	if returnFunc, ok := ret.Get(0).(func(client.ApiUseradmCheckHealthRequest) *http.Response); ok {
		r0 = returnFunc(r)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*http.Response)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(client.ApiUseradmCheckHealthRequest) error); ok {
		r1 = returnFunc(r)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// MockUserAdministrationAndAuthenticationInternalAPIAPI_UseradmCheckHealthExecute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UseradmCheckHealthExecute'
type MockUserAdministrationAndAuthenticationInternalAPIAPI_UseradmCheckHealthExecute_Call struct {
	*mock.Call
}

// UseradmCheckHealthExecute is a helper method to define mock.On call
//   - r client.ApiUseradmCheckHealthRequest
func (_e *MockUserAdministrationAndAuthenticationInternalAPIAPI_Expecter) UseradmCheckHealthExecute(r interface{}) *MockUserAdministrationAndAuthenticationInternalAPIAPI_UseradmCheckHealthExecute_Call {
	return &MockUserAdministrationAndAuthenticationInternalAPIAPI_UseradmCheckHealthExecute_Call{Call: _e.mock.On("UseradmCheckHealthExecute", r)}
}

func (_c *MockUserAdministrationAndAuthenticationInternalAPIAPI_UseradmCheckHealthExecute_Call) Run(run func(r client.ApiUseradmCheckHealthRequest)) *MockUserAdministrationAndAuthenticationInternalAPIAPI_UseradmCheckHealthExecute_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 client.ApiUseradmCheckHealthRequest
		if args[0] != nil {
			arg0 = args[0].(client.ApiUseradmCheckHealthRequest)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *MockUserAdministrationAndAuthenticationInternalAPIAPI_UseradmCheckHealthExecute_Call) Return(response *http.Response, err error) *MockUserAdministrationAndAuthenticationInternalAPIAPI_UseradmCheckHealthExecute_Call {
	_c.Call.Return(response, err)
	return _c
}

func (_c *MockUserAdministrationAndAuthenticationInternalAPIAPI_UseradmCheckHealthExecute_Call) RunAndReturn(run func(r client.ApiUseradmCheckHealthRequest) (*http.Response, error)) *MockUserAdministrationAndAuthenticationInternalAPIAPI_UseradmCheckHealthExecute_Call {
	_c.Call.Return(run)
	return _c
}

// UseradmCheckLiveliness provides a mock function for the type MockUserAdministrationAndAuthenticationInternalAPIAPI
func (_mock *MockUserAdministrationAndAuthenticationInternalAPIAPI) UseradmCheckLiveliness(ctx context.Context) client.ApiUseradmCheckLivelinessRequest {
	ret := _mock.Called(ctx)

	if len(ret) == 0 {
		panic("no return value specified for UseradmCheckLiveliness")
	}

	var r0 client.ApiUseradmCheckLivelinessRequest
	if returnFunc, ok := ret.Get(0).(func(context.Context) client.ApiUseradmCheckLivelinessRequest); ok {
		r0 = returnFunc(ctx)
	} else {
		r0 = ret.Get(0).(client.ApiUseradmCheckLivelinessRequest)
	}
	return r0
}

// MockUserAdministrationAndAuthenticationInternalAPIAPI_UseradmCheckLiveliness_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UseradmCheckLiveliness'
type MockUserAdministrationAndAuthenticationInternalAPIAPI_UseradmCheckLiveliness_Call struct {
	*mock.Call
}

// UseradmCheckLiveliness is a helper method to define mock.On call
//   - ctx context.Context
func (_e *MockUserAdministrationAndAuthenticationInternalAPIAPI_Expecter) UseradmCheckLiveliness(ctx interface{}) *MockUserAdministrationAndAuthenticationInternalAPIAPI_UseradmCheckLiveliness_Call {
	return &MockUserAdministrationAndAuthenticationInternalAPIAPI_UseradmCheckLiveliness_Call{Call: _e.mock.On("UseradmCheckLiveliness", ctx)}
}

func (_c *MockUserAdministrationAndAuthenticationInternalAPIAPI_UseradmCheckLiveliness_Call) Run(run func(ctx context.Context)) *MockUserAdministrationAndAuthenticationInternalAPIAPI_UseradmCheckLiveliness_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *MockUserAdministrationAndAuthenticationInternalAPIAPI_UseradmCheckLiveliness_Call) Return(apiUseradmCheckLivelinessRequest client.ApiUseradmCheckLivelinessRequest) *MockUserAdministrationAndAuthenticationInternalAPIAPI_UseradmCheckLiveliness_Call {
	_c.Call.Return(apiUseradmCheckLivelinessRequest)
	return _c
}

func (_c *MockUserAdministrationAndAuthenticationInternalAPIAPI_UseradmCheckLiveliness_Call) RunAndReturn(run func(ctx context.Context) client.ApiUseradmCheckLivelinessRequest) *MockUserAdministrationAndAuthenticationInternalAPIAPI_UseradmCheckLiveliness_Call {
	_c.Call.Return(run)
	return _c
}

// UseradmCheckLivelinessExecute provides a mock function for the type MockUserAdministrationAndAuthenticationInternalAPIAPI
func (_mock *MockUserAdministrationAndAuthenticationInternalAPIAPI) UseradmCheckLivelinessExecute(r client.ApiUseradmCheckLivelinessRequest) (*http.Response, error) {
	ret := _mock.Called(r)

	if len(ret) == 0 {
		panic("no return value specified for UseradmCheckLivelinessExecute")
	}

	var r0 *http.Response
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(client.ApiUseradmCheckLivelinessRequest) (*http.Response, error)); ok {
		return returnFunc(r)
	}
	if returnFunc, ok := ret.Get(0).(func(client.ApiUseradmCheckLivelinessRequest) *http.Response); ok {
		r0 = returnFunc(r)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*http.Response)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(client.ApiUseradmCheckLivelinessRequest) error); ok {
		r1 = returnFunc(r)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// MockUserAdministrationAndAuthenticationInternalAPIAPI_UseradmCheckLivelinessExecute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UseradmCheckLivelinessExecute'
type MockUserAdministrationAndAuthenticationInternalAPIAPI_UseradmCheckLivelinessExecute_Call struct {
	*mock.Call
}

// UseradmCheckLivelinessExecute is a helper method to define mock.On call
//   - r client.ApiUseradmCheckLivelinessRequest
func (_e *MockUserAdministrationAndAuthenticationInternalAPIAPI_Expecter) UseradmCheckLivelinessExecute(r interface{}) *MockUserAdministrationAndAuthenticationInternalAPIAPI_UseradmCheckLivelinessExecute_Call {
	return &MockUserAdministrationAndAuthenticationInternalAPIAPI_UseradmCheckLivelinessExecute_Call{Call: _e.mock.On("UseradmCheckLivelinessExecute", r)}
}

func (_c *MockUserAdministrationAndAuthenticationInternalAPIAPI_UseradmCheckLivelinessExecute_Call) Run(run func(r client.ApiUseradmCheckLivelinessRequest)) *MockUserAdministrationAndAuthenticationInternalAPIAPI_UseradmCheckLivelinessExecute_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 client.ApiUseradmCheckLivelinessRequest
		if args[0] != nil {
			arg0 = args[0].(client.ApiUseradmCheckLivelinessRequest)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *MockUserAdministrationAndAuthenticationInternalAPIAPI_UseradmCheckLivelinessExecute_Call) Return(response *http.Response, err error) *MockUserAdministrationAndAuthenticationInternalAPIAPI_UseradmCheckLivelinessExecute_Call {
	_c.Call.Return(response, err)
	return _c
}

func (_c *MockUserAdministrationAndAuthenticationInternalAPIAPI_UseradmCheckLivelinessExecute_Call) RunAndReturn(run func(r client.ApiUseradmCheckLivelinessRequest) (*http.Response, error)) *MockUserAdministrationAndAuthenticationInternalAPIAPI_UseradmCheckLivelinessExecute_Call {
	_c.Call.Return(run)
	return _c
}

// UseradmCreateTenant provides a mock function for the type MockUserAdministrationAndAuthenticationInternalAPIAPI
func (_mock *MockUserAdministrationAndAuthenticationInternalAPIAPI) UseradmCreateTenant(ctx context.Context) client.ApiUseradmCreateTenantRequest {
	ret := _mock.Called(ctx)

	if len(ret) == 0 {
		panic("no return value specified for UseradmCreateTenant")
	}

	var r0 client.ApiUseradmCreateTenantRequest
	if returnFunc, ok := ret.Get(0).(func(context.Context) client.ApiUseradmCreateTenantRequest); ok {
		r0 = returnFunc(ctx)
	} else {
		r0 = ret.Get(0).(client.ApiUseradmCreateTenantRequest)
	}
	return r0
}

// MockUserAdministrationAndAuthenticationInternalAPIAPI_UseradmCreateTenant_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UseradmCreateTenant'
type MockUserAdministrationAndAuthenticationInternalAPIAPI_UseradmCreateTenant_Call struct {
	*mock.Call
}

// UseradmCreateTenant is a helper method to define mock.On call
//   - ctx context.Context
func (_e *MockUserAdministrationAndAuthenticationInternalAPIAPI_Expecter) UseradmCreateTenant(ctx interface{}) *MockUserAdministrationAndAuthenticationInternalAPIAPI_UseradmCreateTenant_Call {
	return &MockUserAdministrationAndAuthenticationInternalAPIAPI_UseradmCreateTenant_Call{Call: _e.mock.On("UseradmCreateTenant", ctx)}
}

func (_c *MockUserAdministrationAndAuthenticationInternalAPIAPI_UseradmCreateTenant_Call) Run(run func(ctx context.Context)) *MockUserAdministrationAndAuthenticationInternalAPIAPI_UseradmCreateTenant_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *MockUserAdministrationAndAuthenticationInternalAPIAPI_UseradmCreateTenant_Call) Return(apiUseradmCreateTenantRequest client.ApiUseradmCreateTenantRequest) *MockUserAdministrationAndAuthenticationInternalAPIAPI_UseradmCreateTenant_Call {
	_c.Call.Return(apiUseradmCreateTenantRequest)
	return _c
}

func (_c *MockUserAdministrationAndAuthenticationInternalAPIAPI_UseradmCreateTenant_Call) RunAndReturn(run func(ctx context.Context) client.ApiUseradmCreateTenantRequest) *MockUserAdministrationAndAuthenticationInternalAPIAPI_UseradmCreateTenant_Call {
	_c.Call.Return(run)
	return _c
}

// UseradmCreateTenantExecute provides a mock function for the type MockUserAdministrationAndAuthenticationInternalAPIAPI
func (_mock *MockUserAdministrationAndAuthenticationInternalAPIAPI) UseradmCreateTenantExecute(r client.ApiUseradmCreateTenantRequest) (*http.Response, error) {
	ret := _mock.Called(r)

	if len(ret) == 0 {
		panic("no return value specified for UseradmCreateTenantExecute")
	}

	var r0 *http.Response
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(client.ApiUseradmCreateTenantRequest) (*http.Response, error)); ok {
		return returnFunc(r)
	}
	if returnFunc, ok := ret.Get(0).(func(client.ApiUseradmCreateTenantRequest) *http.Response); ok {
		r0 = returnFunc(r)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*http.Response)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(client.ApiUseradmCreateTenantRequest) error); ok {
		r1 = returnFunc(r)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// MockUserAdministrationAndAuthenticationInternalAPIAPI_UseradmCreateTenantExecute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UseradmCreateTenantExecute'
type MockUserAdministrationAndAuthenticationInternalAPIAPI_UseradmCreateTenantExecute_Call struct {
	*mock.Call
}

// UseradmCreateTenantExecute is a helper method to define mock.On call
//   - r client.ApiUseradmCreateTenantRequest
func (_e *MockUserAdministrationAndAuthenticationInternalAPIAPI_Expecter) UseradmCreateTenantExecute(r interface{}) *MockUserAdministrationAndAuthenticationInternalAPIAPI_UseradmCreateTenantExecute_Call {
	return &MockUserAdministrationAndAuthenticationInternalAPIAPI_UseradmCreateTenantExecute_Call{Call: _e.mock.On("UseradmCreateTenantExecute", r)}
}

func (_c *MockUserAdministrationAndAuthenticationInternalAPIAPI_UseradmCreateTenantExecute_Call) Run(run func(r client.ApiUseradmCreateTenantRequest)) *MockUserAdministrationAndAuthenticationInternalAPIAPI_UseradmCreateTenantExecute_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 client.ApiUseradmCreateTenantRequest
		if args[0] != nil {
			arg0 = args[0].(client.ApiUseradmCreateTenantRequest)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *MockUserAdministrationAndAuthenticationInternalAPIAPI_UseradmCreateTenantExecute_Call) Return(response *http.Response, err error) *MockUserAdministrationAndAuthenticationInternalAPIAPI_UseradmCreateTenantExecute_Call {
	_c.Call.Return(response, err)
	return _c
}

func (_c *MockUserAdministrationAndAuthenticationInternalAPIAPI_UseradmCreateTenantExecute_Call) RunAndReturn(run func(r client.ApiUseradmCreateTenantRequest) (*http.Response, error)) *MockUserAdministrationAndAuthenticationInternalAPIAPI_UseradmCreateTenantExecute_Call {
	_c.Call.Return(run)
	return _c
}

// VerifyJWT provides a mock function for the type MockUserAdministrationAndAuthenticationInternalAPIAPI
func (_mock *MockUserAdministrationAndAuthenticationInternalAPIAPI) VerifyJWT(ctx context.Context) client.ApiVerifyJWTRequest {
	ret := _mock.Called(ctx)

	if len(ret) == 0 {
		panic("no return value specified for VerifyJWT")
	}

	var r0 client.ApiVerifyJWTRequest
	if returnFunc, ok := ret.Get(0).(func(context.Context) client.ApiVerifyJWTRequest); ok {
		r0 = returnFunc(ctx)
	} else {
		r0 = ret.Get(0).(client.ApiVerifyJWTRequest)
	}
	return r0
}

// MockUserAdministrationAndAuthenticationInternalAPIAPI_VerifyJWT_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'VerifyJWT'
type MockUserAdministrationAndAuthenticationInternalAPIAPI_VerifyJWT_Call struct {
	*mock.Call
}

// VerifyJWT is a helper method to define mock.On call
//   - ctx context.Context
func (_e *MockUserAdministrationAndAuthenticationInternalAPIAPI_Expecter) VerifyJWT(ctx interface{}) *MockUserAdministrationAndAuthenticationInternalAPIAPI_VerifyJWT_Call {
	return &MockUserAdministrationAndAuthenticationInternalAPIAPI_VerifyJWT_Call{Call: _e.mock.On("VerifyJWT", ctx)}
}

func (_c *MockUserAdministrationAndAuthenticationInternalAPIAPI_VerifyJWT_Call) Run(run func(ctx context.Context)) *MockUserAdministrationAndAuthenticationInternalAPIAPI_VerifyJWT_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *MockUserAdministrationAndAuthenticationInternalAPIAPI_VerifyJWT_Call) Return(apiVerifyJWTRequest client.ApiVerifyJWTRequest) *MockUserAdministrationAndAuthenticationInternalAPIAPI_VerifyJWT_Call {
	_c.Call.Return(apiVerifyJWTRequest)
	return _c
}

func (_c *MockUserAdministrationAndAuthenticationInternalAPIAPI_VerifyJWT_Call) RunAndReturn(run func(ctx context.Context) client.ApiVerifyJWTRequest) *MockUserAdministrationAndAuthenticationInternalAPIAPI_VerifyJWT_Call {
	_c.Call.Return(run)
	return _c
}

// VerifyJWTExecute provides a mock function for the type MockUserAdministrationAndAuthenticationInternalAPIAPI
func (_mock *MockUserAdministrationAndAuthenticationInternalAPIAPI) VerifyJWTExecute(r client.ApiVerifyJWTRequest) (*http.Response, error) {
	ret := _mock.Called(r)

	if len(ret) == 0 {
		panic("no return value specified for VerifyJWTExecute")
	}

	var r0 *http.Response
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(client.ApiVerifyJWTRequest) (*http.Response, error)); ok {
		return returnFunc(r)
	}
	if returnFunc, ok := ret.Get(0).(func(client.ApiVerifyJWTRequest) *http.Response); ok {
		r0 = returnFunc(r)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*http.Response)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(client.ApiVerifyJWTRequest) error); ok {
		r1 = returnFunc(r)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// MockUserAdministrationAndAuthenticationInternalAPIAPI_VerifyJWTExecute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'VerifyJWTExecute'
type MockUserAdministrationAndAuthenticationInternalAPIAPI_VerifyJWTExecute_Call struct {
	*mock.Call
}

// VerifyJWTExecute is a helper method to define mock.On call
//   - r client.ApiVerifyJWTRequest
func (_e *MockUserAdministrationAndAuthenticationInternalAPIAPI_Expecter) VerifyJWTExecute(r interface{}) *MockUserAdministrationAndAuthenticationInternalAPIAPI_VerifyJWTExecute_Call {
	return &MockUserAdministrationAndAuthenticationInternalAPIAPI_VerifyJWTExecute_Call{Call: _e.mock.On("VerifyJWTExecute", r)}
}

func (_c *MockUserAdministrationAndAuthenticationInternalAPIAPI_VerifyJWTExecute_Call) Run(run func(r client.ApiVerifyJWTRequest)) *MockUserAdministrationAndAuthenticationInternalAPIAPI_VerifyJWTExecute_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 client.ApiVerifyJWTRequest
		if args[0] != nil {
			arg0 = args[0].(client.ApiVerifyJWTRequest)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *MockUserAdministrationAndAuthenticationInternalAPIAPI_VerifyJWTExecute_Call) Return(response *http.Response, err error) *MockUserAdministrationAndAuthenticationInternalAPIAPI_VerifyJWTExecute_Call {
	_c.Call.Return(response, err)
	return _c
}

func (_c *MockUserAdministrationAndAuthenticationInternalAPIAPI_VerifyJWTExecute_Call) RunAndReturn(run func(r client.ApiVerifyJWTRequest) (*http.Response, error)) *MockUserAdministrationAndAuthenticationInternalAPIAPI_VerifyJWTExecute_Call {
	_c.Call.Return(run)
	return _c
}

// NewMockUserAdministrationManagementAPIAPI creates a new instance of MockUserAdministrationManagementAPIAPI. 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 NewMockUserAdministrationManagementAPIAPI(t interface {
	mock.TestingT
	Cleanup(func())
}) *MockUserAdministrationManagementAPIAPI {
	mock := &MockUserAdministrationManagementAPIAPI{}
	mock.Mock.Test(t)

	t.Cleanup(func() { mock.AssertExpectations(t) })

	return mock
}

// MockUserAdministrationManagementAPIAPI is an autogenerated mock type for the UserAdministrationManagementAPIAPI type
type MockUserAdministrationManagementAPIAPI struct {
	mock.Mock
}

type MockUserAdministrationManagementAPIAPI_Expecter struct {
	mock *mock.Mock
}

func (_m *MockUserAdministrationManagementAPIAPI) EXPECT() *MockUserAdministrationManagementAPIAPI_Expecter {
	return &MockUserAdministrationManagementAPIAPI_Expecter{mock: &_m.Mock}
}

// CreatePersonalAccessToken provides a mock function for the type MockUserAdministrationManagementAPIAPI
func (_mock *MockUserAdministrationManagementAPIAPI) CreatePersonalAccessToken(ctx context.Context) client.ApiCreatePersonalAccessTokenRequest {
	ret := _mock.Called(ctx)

	if len(ret) == 0 {
		panic("no return value specified for CreatePersonalAccessToken")
	}

	var r0 client.ApiCreatePersonalAccessTokenRequest
	if returnFunc, ok := ret.Get(0).(func(context.Context) client.ApiCreatePersonalAccessTokenRequest); ok {
		r0 = returnFunc(ctx)
	} else {
		r0 = ret.Get(0).(client.ApiCreatePersonalAccessTokenRequest)
	}
	return r0
}

// MockUserAdministrationManagementAPIAPI_CreatePersonalAccessToken_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreatePersonalAccessToken'
type MockUserAdministrationManagementAPIAPI_CreatePersonalAccessToken_Call struct {
	*mock.Call
}

// CreatePersonalAccessToken is a helper method to define mock.On call
//   - ctx context.Context
func (_e *MockUserAdministrationManagementAPIAPI_Expecter) CreatePersonalAccessToken(ctx interface{}) *MockUserAdministrationManagementAPIAPI_CreatePersonalAccessToken_Call {
	return &MockUserAdministrationManagementAPIAPI_CreatePersonalAccessToken_Call{Call: _e.mock.On("CreatePersonalAccessToken", ctx)}
}

func (_c *MockUserAdministrationManagementAPIAPI_CreatePersonalAccessToken_Call) Run(run func(ctx context.Context)) *MockUserAdministrationManagementAPIAPI_CreatePersonalAccessToken_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *MockUserAdministrationManagementAPIAPI_CreatePersonalAccessToken_Call) Return(apiCreatePersonalAccessTokenRequest client.ApiCreatePersonalAccessTokenRequest) *MockUserAdministrationManagementAPIAPI_CreatePersonalAccessToken_Call {
	_c.Call.Return(apiCreatePersonalAccessTokenRequest)
	return _c
}

func (_c *MockUserAdministrationManagementAPIAPI_CreatePersonalAccessToken_Call) RunAndReturn(run func(ctx context.Context) client.ApiCreatePersonalAccessTokenRequest) *MockUserAdministrationManagementAPIAPI_CreatePersonalAccessToken_Call {
	_c.Call.Return(run)
	return _c
}

// CreatePersonalAccessTokenExecute provides a mock function for the type MockUserAdministrationManagementAPIAPI
func (_mock *MockUserAdministrationManagementAPIAPI) CreatePersonalAccessTokenExecute(r client.ApiCreatePersonalAccessTokenRequest) (string, *http.Response, error) {
	ret := _mock.Called(r)

	if len(ret) == 0 {
		panic("no return value specified for CreatePersonalAccessTokenExecute")
	}

	var r0 string
	var r1 *http.Response
	var r2 error
	if returnFunc, ok := ret.Get(0).(func(client.ApiCreatePersonalAccessTokenRequest) (string, *http.Response, error)); ok {
		return returnFunc(r)
	}
	if returnFunc, ok := ret.Get(0).(func(client.ApiCreatePersonalAccessTokenRequest) string); ok {
		r0 = returnFunc(r)
	} else {
		r0 = ret.Get(0).(string)
	}
	if returnFunc, ok := ret.Get(1).(func(client.ApiCreatePersonalAccessTokenRequest) *http.Response); ok {
		r1 = returnFunc(r)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*http.Response)
		}
	}
	if returnFunc, ok := ret.Get(2).(func(client.ApiCreatePersonalAccessTokenRequest) error); ok {
		r2 = returnFunc(r)
	} else {
		r2 = ret.Error(2)
	}
	return r0, r1, r2
}

// MockUserAdministrationManagementAPIAPI_CreatePersonalAccessTokenExecute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreatePersonalAccessTokenExecute'
type MockUserAdministrationManagementAPIAPI_CreatePersonalAccessTokenExecute_Call struct {
	*mock.Call
}

// CreatePersonalAccessTokenExecute is a helper method to define mock.On call
//   - r client.ApiCreatePersonalAccessTokenRequest
func (_e *MockUserAdministrationManagementAPIAPI_Expecter) CreatePersonalAccessTokenExecute(r interface{}) *MockUserAdministrationManagementAPIAPI_CreatePersonalAccessTokenExecute_Call {
	return &MockUserAdministrationManagementAPIAPI_CreatePersonalAccessTokenExecute_Call{Call: _e.mock.On("CreatePersonalAccessTokenExecute", r)}
}

func (_c *MockUserAdministrationManagementAPIAPI_CreatePersonalAccessTokenExecute_Call) Run(run func(r client.ApiCreatePersonalAccessTokenRequest)) *MockUserAdministrationManagementAPIAPI_CreatePersonalAccessTokenExecute_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 client.ApiCreatePersonalAccessTokenRequest
		if args[0] != nil {
			arg0 = args[0].(client.ApiCreatePersonalAccessTokenRequest)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *MockUserAdministrationManagementAPIAPI_CreatePersonalAccessTokenExecute_Call) Return(s string, response *http.Response, err error) *MockUserAdministrationManagementAPIAPI_CreatePersonalAccessTokenExecute_Call {
	_c.Call.Return(s, response, err)
	return _c
}

func (_c *MockUserAdministrationManagementAPIAPI_CreatePersonalAccessTokenExecute_Call) RunAndReturn(run func(r client.ApiCreatePersonalAccessTokenRequest) (string, *http.Response, error)) *MockUserAdministrationManagementAPIAPI_CreatePersonalAccessTokenExecute_Call {
	_c.Call.Return(run)
	return _c
}

// CreateUserManagement provides a mock function for the type MockUserAdministrationManagementAPIAPI
func (_mock *MockUserAdministrationManagementAPIAPI) CreateUserManagement(ctx context.Context) client.ApiCreateUserManagementRequest {
	ret := _mock.Called(ctx)

	if len(ret) == 0 {
		panic("no return value specified for CreateUserManagement")
	}

	var r0 client.ApiCreateUserManagementRequest
	if returnFunc, ok := ret.Get(0).(func(context.Context) client.ApiCreateUserManagementRequest); ok {
		r0 = returnFunc(ctx)
	} else {
		r0 = ret.Get(0).(client.ApiCreateUserManagementRequest)
	}
	return r0
}

// MockUserAdministrationManagementAPIAPI_CreateUserManagement_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateUserManagement'
type MockUserAdministrationManagementAPIAPI_CreateUserManagement_Call struct {
	*mock.Call
}

// CreateUserManagement is a helper method to define mock.On call
//   - ctx context.Context
func (_e *MockUserAdministrationManagementAPIAPI_Expecter) CreateUserManagement(ctx interface{}) *MockUserAdministrationManagementAPIAPI_CreateUserManagement_Call {
	return &MockUserAdministrationManagementAPIAPI_CreateUserManagement_Call{Call: _e.mock.On("CreateUserManagement", ctx)}
}

func (_c *MockUserAdministrationManagementAPIAPI_CreateUserManagement_Call) Run(run func(ctx context.Context)) *MockUserAdministrationManagementAPIAPI_CreateUserManagement_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *MockUserAdministrationManagementAPIAPI_CreateUserManagement_Call) Return(apiCreateUserManagementRequest client.ApiCreateUserManagementRequest) *MockUserAdministrationManagementAPIAPI_CreateUserManagement_Call {
	_c.Call.Return(apiCreateUserManagementRequest)
	return _c
}

func (_c *MockUserAdministrationManagementAPIAPI_CreateUserManagement_Call) RunAndReturn(run func(ctx context.Context) client.ApiCreateUserManagementRequest) *MockUserAdministrationManagementAPIAPI_CreateUserManagement_Call {
	_c.Call.Return(run)
	return _c
}

// CreateUserManagementExecute provides a mock function for the type MockUserAdministrationManagementAPIAPI
func (_mock *MockUserAdministrationManagementAPIAPI) CreateUserManagementExecute(r client.ApiCreateUserManagementRequest) (*http.Response, error) {
	ret := _mock.Called(r)

	if len(ret) == 0 {
		panic("no return value specified for CreateUserManagementExecute")
	}

	var r0 *http.Response
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(client.ApiCreateUserManagementRequest) (*http.Response, error)); ok {
		return returnFunc(r)
	}
	if returnFunc, ok := ret.Get(0).(func(client.ApiCreateUserManagementRequest) *http.Response); ok {
		r0 = returnFunc(r)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*http.Response)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(client.ApiCreateUserManagementRequest) error); ok {
		r1 = returnFunc(r)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// MockUserAdministrationManagementAPIAPI_CreateUserManagementExecute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateUserManagementExecute'
type MockUserAdministrationManagementAPIAPI_CreateUserManagementExecute_Call struct {
	*mock.Call
}

// CreateUserManagementExecute is a helper method to define mock.On call
//   - r client.ApiCreateUserManagementRequest
func (_e *MockUserAdministrationManagementAPIAPI_Expecter) CreateUserManagementExecute(r interface{}) *MockUserAdministrationManagementAPIAPI_CreateUserManagementExecute_Call {
	return &MockUserAdministrationManagementAPIAPI_CreateUserManagementExecute_Call{Call: _e.mock.On("CreateUserManagementExecute", r)}
}

func (_c *MockUserAdministrationManagementAPIAPI_CreateUserManagementExecute_Call) Run(run func(r client.ApiCreateUserManagementRequest)) *MockUserAdministrationManagementAPIAPI_CreateUserManagementExecute_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 client.ApiCreateUserManagementRequest
		if args[0] != nil {
			arg0 = args[0].(client.ApiCreateUserManagementRequest)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *MockUserAdministrationManagementAPIAPI_CreateUserManagementExecute_Call) Return(response *http.Response, err error) *MockUserAdministrationManagementAPIAPI_CreateUserManagementExecute_Call {
	_c.Call.Return(response, err)
	return _c
}

func (_c *MockUserAdministrationManagementAPIAPI_CreateUserManagementExecute_Call) RunAndReturn(run func(r client.ApiCreateUserManagementRequest) (*http.Response, error)) *MockUserAdministrationManagementAPIAPI_CreateUserManagementExecute_Call {
	_c.Call.Return(run)
	return _c
}

// ListPlans provides a mock function for the type MockUserAdministrationManagementAPIAPI
func (_mock *MockUserAdministrationManagementAPIAPI) ListPlans(ctx context.Context) client.ApiListPlansRequest {
	ret := _mock.Called(ctx)

	if len(ret) == 0 {
		panic("no return value specified for ListPlans")
	}

	var r0 client.ApiListPlansRequest
	if returnFunc, ok := ret.Get(0).(func(context.Context) client.ApiListPlansRequest); ok {
		r0 = returnFunc(ctx)
	} else {
		r0 = ret.Get(0).(client.ApiListPlansRequest)
	}
	return r0
}

// MockUserAdministrationManagementAPIAPI_ListPlans_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListPlans'
type MockUserAdministrationManagementAPIAPI_ListPlans_Call struct {
	*mock.Call
}

// ListPlans is a helper method to define mock.On call
//   - ctx context.Context
func (_e *MockUserAdministrationManagementAPIAPI_Expecter) ListPlans(ctx interface{}) *MockUserAdministrationManagementAPIAPI_ListPlans_Call {
	return &MockUserAdministrationManagementAPIAPI_ListPlans_Call{Call: _e.mock.On("ListPlans", ctx)}
}

func (_c *MockUserAdministrationManagementAPIAPI_ListPlans_Call) Run(run func(ctx context.Context)) *MockUserAdministrationManagementAPIAPI_ListPlans_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *MockUserAdministrationManagementAPIAPI_ListPlans_Call) Return(apiListPlansRequest client.ApiListPlansRequest) *MockUserAdministrationManagementAPIAPI_ListPlans_Call {
	_c.Call.Return(apiListPlansRequest)
	return _c
}

func (_c *MockUserAdministrationManagementAPIAPI_ListPlans_Call) RunAndReturn(run func(ctx context.Context) client.ApiListPlansRequest) *MockUserAdministrationManagementAPIAPI_ListPlans_Call {
	_c.Call.Return(run)
	return _c
}

// ListPlansExecute provides a mock function for the type MockUserAdministrationManagementAPIAPI
func (_mock *MockUserAdministrationManagementAPIAPI) ListPlansExecute(r client.ApiListPlansRequest) ([]client.Plan, *http.Response, error) {
	ret := _mock.Called(r)

	if len(ret) == 0 {
		panic("no return value specified for ListPlansExecute")
	}

	var r0 []client.Plan
	var r1 *http.Response
	var r2 error
	if returnFunc, ok := ret.Get(0).(func(client.ApiListPlansRequest) ([]client.Plan, *http.Response, error)); ok {
		return returnFunc(r)
	}
	if returnFunc, ok := ret.Get(0).(func(client.ApiListPlansRequest) []client.Plan); ok {
		r0 = returnFunc(r)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]client.Plan)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(client.ApiListPlansRequest) *http.Response); ok {
		r1 = returnFunc(r)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*http.Response)
		}
	}
	if returnFunc, ok := ret.Get(2).(func(client.ApiListPlansRequest) error); ok {
		r2 = returnFunc(r)
	} else {
		r2 = ret.Error(2)
	}
	return r0, r1, r2
}

// MockUserAdministrationManagementAPIAPI_ListPlansExecute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListPlansExecute'
type MockUserAdministrationManagementAPIAPI_ListPlansExecute_Call struct {
	*mock.Call
}

// ListPlansExecute is a helper method to define mock.On call
//   - r client.ApiListPlansRequest
func (_e *MockUserAdministrationManagementAPIAPI_Expecter) ListPlansExecute(r interface{}) *MockUserAdministrationManagementAPIAPI_ListPlansExecute_Call {
	return &MockUserAdministrationManagementAPIAPI_ListPlansExecute_Call{Call: _e.mock.On("ListPlansExecute", r)}
}

func (_c *MockUserAdministrationManagementAPIAPI_ListPlansExecute_Call) Run(run func(r client.ApiListPlansRequest)) *MockUserAdministrationManagementAPIAPI_ListPlansExecute_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 client.ApiListPlansRequest
		if args[0] != nil {
			arg0 = args[0].(client.ApiListPlansRequest)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *MockUserAdministrationManagementAPIAPI_ListPlansExecute_Call) Return(plans []client.Plan, response *http.Response, err error) *MockUserAdministrationManagementAPIAPI_ListPlansExecute_Call {
	_c.Call.Return(plans, response, err)
	return _c
}

func (_c *MockUserAdministrationManagementAPIAPI_ListPlansExecute_Call) RunAndReturn(run func(r client.ApiListPlansRequest) ([]client.Plan, *http.Response, error)) *MockUserAdministrationManagementAPIAPI_ListPlansExecute_Call {
	_c.Call.Return(run)
	return _c
}

// ListUserPersonalAccessTokens provides a mock function for the type MockUserAdministrationManagementAPIAPI
func (_mock *MockUserAdministrationManagementAPIAPI) ListUserPersonalAccessTokens(ctx context.Context) client.ApiListUserPersonalAccessTokensRequest {
	ret := _mock.Called(ctx)

	if len(ret) == 0 {
		panic("no return value specified for ListUserPersonalAccessTokens")
	}

	var r0 client.ApiListUserPersonalAccessTokensRequest
	if returnFunc, ok := ret.Get(0).(func(context.Context) client.ApiListUserPersonalAccessTokensRequest); ok {
		r0 = returnFunc(ctx)
	} else {
		r0 = ret.Get(0).(client.ApiListUserPersonalAccessTokensRequest)
	}
	return r0
}

// MockUserAdministrationManagementAPIAPI_ListUserPersonalAccessTokens_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListUserPersonalAccessTokens'
type MockUserAdministrationManagementAPIAPI_ListUserPersonalAccessTokens_Call struct {
	*mock.Call
}

// ListUserPersonalAccessTokens is a helper method to define mock.On call
//   - ctx context.Context
func (_e *MockUserAdministrationManagementAPIAPI_Expecter) ListUserPersonalAccessTokens(ctx interface{}) *MockUserAdministrationManagementAPIAPI_ListUserPersonalAccessTokens_Call {
	return &MockUserAdministrationManagementAPIAPI_ListUserPersonalAccessTokens_Call{Call: _e.mock.On("ListUserPersonalAccessTokens", ctx)}
}

func (_c *MockUserAdministrationManagementAPIAPI_ListUserPersonalAccessTokens_Call) Run(run func(ctx context.Context)) *MockUserAdministrationManagementAPIAPI_ListUserPersonalAccessTokens_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *MockUserAdministrationManagementAPIAPI_ListUserPersonalAccessTokens_Call) Return(apiListUserPersonalAccessTokensRequest client.ApiListUserPersonalAccessTokensRequest) *MockUserAdministrationManagementAPIAPI_ListUserPersonalAccessTokens_Call {
	_c.Call.Return(apiListUserPersonalAccessTokensRequest)
	return _c
}

func (_c *MockUserAdministrationManagementAPIAPI_ListUserPersonalAccessTokens_Call) RunAndReturn(run func(ctx context.Context) client.ApiListUserPersonalAccessTokensRequest) *MockUserAdministrationManagementAPIAPI_ListUserPersonalAccessTokens_Call {
	_c.Call.Return(run)
	return _c
}

// ListUserPersonalAccessTokensExecute provides a mock function for the type MockUserAdministrationManagementAPIAPI
func (_mock *MockUserAdministrationManagementAPIAPI) ListUserPersonalAccessTokensExecute(r client.ApiListUserPersonalAccessTokensRequest) ([]client.PersonalAccessToken, *http.Response, error) {
	ret := _mock.Called(r)

	if len(ret) == 0 {
		panic("no return value specified for ListUserPersonalAccessTokensExecute")
	}

	var r0 []client.PersonalAccessToken
	var r1 *http.Response
	var r2 error
	if returnFunc, ok := ret.Get(0).(func(client.ApiListUserPersonalAccessTokensRequest) ([]client.PersonalAccessToken, *http.Response, error)); ok {
		return returnFunc(r)
	}
	if returnFunc, ok := ret.Get(0).(func(client.ApiListUserPersonalAccessTokensRequest) []client.PersonalAccessToken); ok {
		r0 = returnFunc(r)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]client.PersonalAccessToken)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(client.ApiListUserPersonalAccessTokensRequest) *http.Response); ok {
		r1 = returnFunc(r)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*http.Response)
		}
	}
	if returnFunc, ok := ret.Get(2).(func(client.ApiListUserPersonalAccessTokensRequest) error); ok {
		r2 = returnFunc(r)
	} else {
		r2 = ret.Error(2)
	}
	return r0, r1, r2
}

// MockUserAdministrationManagementAPIAPI_ListUserPersonalAccessTokensExecute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListUserPersonalAccessTokensExecute'
type MockUserAdministrationManagementAPIAPI_ListUserPersonalAccessTokensExecute_Call struct {
	*mock.Call
}

// ListUserPersonalAccessTokensExecute is a helper method to define mock.On call
//   - r client.ApiListUserPersonalAccessTokensRequest
func (_e *MockUserAdministrationManagementAPIAPI_Expecter) ListUserPersonalAccessTokensExecute(r interface{}) *MockUserAdministrationManagementAPIAPI_ListUserPersonalAccessTokensExecute_Call {
	return &MockUserAdministrationManagementAPIAPI_ListUserPersonalAccessTokensExecute_Call{Call: _e.mock.On("ListUserPersonalAccessTokensExecute", r)}
}

func (_c *MockUserAdministrationManagementAPIAPI_ListUserPersonalAccessTokensExecute_Call) Run(run func(r client.ApiListUserPersonalAccessTokensRequest)) *MockUserAdministrationManagementAPIAPI_ListUserPersonalAccessTokensExecute_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 client.ApiListUserPersonalAccessTokensRequest
		if args[0] != nil {
			arg0 = args[0].(client.ApiListUserPersonalAccessTokensRequest)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *MockUserAdministrationManagementAPIAPI_ListUserPersonalAccessTokensExecute_Call) Return(personalAccessTokens []client.PersonalAccessToken, response *http.Response, err error) *MockUserAdministrationManagementAPIAPI_ListUserPersonalAccessTokensExecute_Call {
	_c.Call.Return(personalAccessTokens, response, err)
	return _c
}

func (_c *MockUserAdministrationManagementAPIAPI_ListUserPersonalAccessTokensExecute_Call) RunAndReturn(run func(r client.ApiListUserPersonalAccessTokensRequest) ([]client.PersonalAccessToken, *http.Response, error)) *MockUserAdministrationManagementAPIAPI_ListUserPersonalAccessTokensExecute_Call {
	_c.Call.Return(run)
	return _c
}

// ListUsersManagement provides a mock function for the type MockUserAdministrationManagementAPIAPI
func (_mock *MockUserAdministrationManagementAPIAPI) ListUsersManagement(ctx context.Context) client.ApiListUsersManagementRequest {
	ret := _mock.Called(ctx)

	if len(ret) == 0 {
		panic("no return value specified for ListUsersManagement")
	}

	var r0 client.ApiListUsersManagementRequest
	if returnFunc, ok := ret.Get(0).(func(context.Context) client.ApiListUsersManagementRequest); ok {
		r0 = returnFunc(ctx)
	} else {
		r0 = ret.Get(0).(client.ApiListUsersManagementRequest)
	}
	return r0
}

// MockUserAdministrationManagementAPIAPI_ListUsersManagement_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListUsersManagement'
type MockUserAdministrationManagementAPIAPI_ListUsersManagement_Call struct {
	*mock.Call
}

// ListUsersManagement is a helper method to define mock.On call
//   - ctx context.Context
func (_e *MockUserAdministrationManagementAPIAPI_Expecter) ListUsersManagement(ctx interface{}) *MockUserAdministrationManagementAPIAPI_ListUsersManagement_Call {
	return &MockUserAdministrationManagementAPIAPI_ListUsersManagement_Call{Call: _e.mock.On("ListUsersManagement", ctx)}
}

func (_c *MockUserAdministrationManagementAPIAPI_ListUsersManagement_Call) Run(run func(ctx context.Context)) *MockUserAdministrationManagementAPIAPI_ListUsersManagement_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *MockUserAdministrationManagementAPIAPI_ListUsersManagement_Call) Return(apiListUsersManagementRequest client.ApiListUsersManagementRequest) *MockUserAdministrationManagementAPIAPI_ListUsersManagement_Call {
	_c.Call.Return(apiListUsersManagementRequest)
	return _c
}

func (_c *MockUserAdministrationManagementAPIAPI_ListUsersManagement_Call) RunAndReturn(run func(ctx context.Context) client.ApiListUsersManagementRequest) *MockUserAdministrationManagementAPIAPI_ListUsersManagement_Call {
	_c.Call.Return(run)
	return _c
}

// ListUsersManagementExecute provides a mock function for the type MockUserAdministrationManagementAPIAPI
func (_mock *MockUserAdministrationManagementAPIAPI) ListUsersManagementExecute(r client.ApiListUsersManagementRequest) ([]client.User, *http.Response, error) {
	ret := _mock.Called(r)

	if len(ret) == 0 {
		panic("no return value specified for ListUsersManagementExecute")
	}

	var r0 []client.User
	var r1 *http.Response
	var r2 error
	if returnFunc, ok := ret.Get(0).(func(client.ApiListUsersManagementRequest) ([]client.User, *http.Response, error)); ok {
		return returnFunc(r)
	}
	if returnFunc, ok := ret.Get(0).(func(client.ApiListUsersManagementRequest) []client.User); ok {
		r0 = returnFunc(r)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]client.User)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(client.ApiListUsersManagementRequest) *http.Response); ok {
		r1 = returnFunc(r)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*http.Response)
		}
	}
	if returnFunc, ok := ret.Get(2).(func(client.ApiListUsersManagementRequest) error); ok {
		r2 = returnFunc(r)
	} else {
		r2 = ret.Error(2)
	}
	return r0, r1, r2
}

// MockUserAdministrationManagementAPIAPI_ListUsersManagementExecute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListUsersManagementExecute'
type MockUserAdministrationManagementAPIAPI_ListUsersManagementExecute_Call struct {
	*mock.Call
}

// ListUsersManagementExecute is a helper method to define mock.On call
//   - r client.ApiListUsersManagementRequest
func (_e *MockUserAdministrationManagementAPIAPI_Expecter) ListUsersManagementExecute(r interface{}) *MockUserAdministrationManagementAPIAPI_ListUsersManagementExecute_Call {
	return &MockUserAdministrationManagementAPIAPI_ListUsersManagementExecute_Call{Call: _e.mock.On("ListUsersManagementExecute", r)}
}

func (_c *MockUserAdministrationManagementAPIAPI_ListUsersManagementExecute_Call) Run(run func(r client.ApiListUsersManagementRequest)) *MockUserAdministrationManagementAPIAPI_ListUsersManagementExecute_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 client.ApiListUsersManagementRequest
		if args[0] != nil {
			arg0 = args[0].(client.ApiListUsersManagementRequest)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *MockUserAdministrationManagementAPIAPI_ListUsersManagementExecute_Call) Return(users []client.User, response *http.Response, err error) *MockUserAdministrationManagementAPIAPI_ListUsersManagementExecute_Call {
	_c.Call.Return(users, response, err)
	return _c
}

func (_c *MockUserAdministrationManagementAPIAPI_ListUsersManagementExecute_Call) RunAndReturn(run func(r client.ApiListUsersManagementRequest) ([]client.User, *http.Response, error)) *MockUserAdministrationManagementAPIAPI_ListUsersManagementExecute_Call {
	_c.Call.Return(run)
	return _c
}

// Login provides a mock function for the type MockUserAdministrationManagementAPIAPI
func (_mock *MockUserAdministrationManagementAPIAPI) Login(ctx context.Context) client.ApiLoginRequest {
	ret := _mock.Called(ctx)

	if len(ret) == 0 {
		panic("no return value specified for Login")
	}

	var r0 client.ApiLoginRequest
	if returnFunc, ok := ret.Get(0).(func(context.Context) client.ApiLoginRequest); ok {
		r0 = returnFunc(ctx)
	} else {
		r0 = ret.Get(0).(client.ApiLoginRequest)
	}
	return r0
}

// MockUserAdministrationManagementAPIAPI_Login_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Login'
type MockUserAdministrationManagementAPIAPI_Login_Call struct {
	*mock.Call
}

// Login is a helper method to define mock.On call
//   - ctx context.Context
func (_e *MockUserAdministrationManagementAPIAPI_Expecter) Login(ctx interface{}) *MockUserAdministrationManagementAPIAPI_Login_Call {
	return &MockUserAdministrationManagementAPIAPI_Login_Call{Call: _e.mock.On("Login", ctx)}
}

func (_c *MockUserAdministrationManagementAPIAPI_Login_Call) Run(run func(ctx context.Context)) *MockUserAdministrationManagementAPIAPI_Login_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *MockUserAdministrationManagementAPIAPI_Login_Call) Return(apiLoginRequest client.ApiLoginRequest) *MockUserAdministrationManagementAPIAPI_Login_Call {
	_c.Call.Return(apiLoginRequest)
	return _c
}

func (_c *MockUserAdministrationManagementAPIAPI_Login_Call) RunAndReturn(run func(ctx context.Context) client.ApiLoginRequest) *MockUserAdministrationManagementAPIAPI_Login_Call {
	_c.Call.Return(run)
	return _c
}

// LoginExecute provides a mock function for the type MockUserAdministrationManagementAPIAPI
func (_mock *MockUserAdministrationManagementAPIAPI) LoginExecute(r client.ApiLoginRequest) (string, *http.Response, error) {
	ret := _mock.Called(r)

	if len(ret) == 0 {
		panic("no return value specified for LoginExecute")
	}

	var r0 string
	var r1 *http.Response
	var r2 error
	if returnFunc, ok := ret.Get(0).(func(client.ApiLoginRequest) (string, *http.Response, error)); ok {
		return returnFunc(r)
	}
	if returnFunc, ok := ret.Get(0).(func(client.ApiLoginRequest) string); ok {
		r0 = returnFunc(r)
	} else {
		r0 = ret.Get(0).(string)
	}
	if returnFunc, ok := ret.Get(1).(func(client.ApiLoginRequest) *http.Response); ok {
		r1 = returnFunc(r)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*http.Response)
		}
	}
	if returnFunc, ok := ret.Get(2).(func(client.ApiLoginRequest) error); ok {
		r2 = returnFunc(r)
	} else {
		r2 = ret.Error(2)
	}
	return r0, r1, r2
}

// MockUserAdministrationManagementAPIAPI_LoginExecute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'LoginExecute'
type MockUserAdministrationManagementAPIAPI_LoginExecute_Call struct {
	*mock.Call
}

// LoginExecute is a helper method to define mock.On call
//   - r client.ApiLoginRequest
func (_e *MockUserAdministrationManagementAPIAPI_Expecter) LoginExecute(r interface{}) *MockUserAdministrationManagementAPIAPI_LoginExecute_Call {
	return &MockUserAdministrationManagementAPIAPI_LoginExecute_Call{Call: _e.mock.On("LoginExecute", r)}
}

func (_c *MockUserAdministrationManagementAPIAPI_LoginExecute_Call) Run(run func(r client.ApiLoginRequest)) *MockUserAdministrationManagementAPIAPI_LoginExecute_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 client.ApiLoginRequest
		if args[0] != nil {
			arg0 = args[0].(client.ApiLoginRequest)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *MockUserAdministrationManagementAPIAPI_LoginExecute_Call) Return(s string, response *http.Response, err error) *MockUserAdministrationManagementAPIAPI_LoginExecute_Call {
	_c.Call.Return(s, response, err)
	return _c
}

func (_c *MockUserAdministrationManagementAPIAPI_LoginExecute_Call) RunAndReturn(run func(r client.ApiLoginRequest) (string, *http.Response, error)) *MockUserAdministrationManagementAPIAPI_LoginExecute_Call {
	_c.Call.Return(run)
	return _c
}

// Logout provides a mock function for the type MockUserAdministrationManagementAPIAPI
func (_mock *MockUserAdministrationManagementAPIAPI) Logout(ctx context.Context) client.ApiLogoutRequest {
	ret := _mock.Called(ctx)

	if len(ret) == 0 {
		panic("no return value specified for Logout")
	}

	var r0 client.ApiLogoutRequest
	if returnFunc, ok := ret.Get(0).(func(context.Context) client.ApiLogoutRequest); ok {
		r0 = returnFunc(ctx)
	} else {
		r0 = ret.Get(0).(client.ApiLogoutRequest)
	}
	return r0
}

// MockUserAdministrationManagementAPIAPI_Logout_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Logout'
type MockUserAdministrationManagementAPIAPI_Logout_Call struct {
	*mock.Call
}

// Logout is a helper method to define mock.On call
//   - ctx context.Context
func (_e *MockUserAdministrationManagementAPIAPI_Expecter) Logout(ctx interface{}) *MockUserAdministrationManagementAPIAPI_Logout_Call {
	return &MockUserAdministrationManagementAPIAPI_Logout_Call{Call: _e.mock.On("Logout", ctx)}
}

func (_c *MockUserAdministrationManagementAPIAPI_Logout_Call) Run(run func(ctx context.Context)) *MockUserAdministrationManagementAPIAPI_Logout_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *MockUserAdministrationManagementAPIAPI_Logout_Call) Return(apiLogoutRequest client.ApiLogoutRequest) *MockUserAdministrationManagementAPIAPI_Logout_Call {
	_c.Call.Return(apiLogoutRequest)
	return _c
}

func (_c *MockUserAdministrationManagementAPIAPI_Logout_Call) RunAndReturn(run func(ctx context.Context) client.ApiLogoutRequest) *MockUserAdministrationManagementAPIAPI_Logout_Call {
	_c.Call.Return(run)
	return _c
}

// LogoutExecute provides a mock function for the type MockUserAdministrationManagementAPIAPI
func (_mock *MockUserAdministrationManagementAPIAPI) LogoutExecute(r client.ApiLogoutRequest) (*http.Response, error) {
	ret := _mock.Called(r)

	if len(ret) == 0 {
		panic("no return value specified for LogoutExecute")
	}

	var r0 *http.Response
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(client.ApiLogoutRequest) (*http.Response, error)); ok {
		return returnFunc(r)
	}
	if returnFunc, ok := ret.Get(0).(func(client.ApiLogoutRequest) *http.Response); ok {
		r0 = returnFunc(r)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*http.Response)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(client.ApiLogoutRequest) error); ok {
		r1 = returnFunc(r)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// MockUserAdministrationManagementAPIAPI_LogoutExecute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'LogoutExecute'
type MockUserAdministrationManagementAPIAPI_LogoutExecute_Call struct {
	*mock.Call
}

// LogoutExecute is a helper method to define mock.On call
//   - r client.ApiLogoutRequest
func (_e *MockUserAdministrationManagementAPIAPI_Expecter) LogoutExecute(r interface{}) *MockUserAdministrationManagementAPIAPI_LogoutExecute_Call {
	return &MockUserAdministrationManagementAPIAPI_LogoutExecute_Call{Call: _e.mock.On("LogoutExecute", r)}
}

func (_c *MockUserAdministrationManagementAPIAPI_LogoutExecute_Call) Run(run func(r client.ApiLogoutRequest)) *MockUserAdministrationManagementAPIAPI_LogoutExecute_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 client.ApiLogoutRequest
		if args[0] != nil {
			arg0 = args[0].(client.ApiLogoutRequest)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *MockUserAdministrationManagementAPIAPI_LogoutExecute_Call) Return(response *http.Response, err error) *MockUserAdministrationManagementAPIAPI_LogoutExecute_Call {
	_c.Call.Return(response, err)
	return _c
}

func (_c *MockUserAdministrationManagementAPIAPI_LogoutExecute_Call) RunAndReturn(run func(r client.ApiLogoutRequest) (*http.Response, error)) *MockUserAdministrationManagementAPIAPI_LogoutExecute_Call {
	_c.Call.Return(run)
	return _c
}

// RemoveUser provides a mock function for the type MockUserAdministrationManagementAPIAPI
func (_mock *MockUserAdministrationManagementAPIAPI) RemoveUser(ctx context.Context, id string) client.ApiRemoveUserRequest {
	ret := _mock.Called(ctx, id)

	if len(ret) == 0 {
		panic("no return value specified for RemoveUser")
	}

	var r0 client.ApiRemoveUserRequest
	if returnFunc, ok := ret.Get(0).(func(context.Context, string) client.ApiRemoveUserRequest); ok {
		r0 = returnFunc(ctx, id)
	} else {
		r0 = ret.Get(0).(client.ApiRemoveUserRequest)
	}
	return r0
}

// MockUserAdministrationManagementAPIAPI_RemoveUser_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RemoveUser'
type MockUserAdministrationManagementAPIAPI_RemoveUser_Call struct {
	*mock.Call
}

// RemoveUser is a helper method to define mock.On call
//   - ctx context.Context
//   - id string
func (_e *MockUserAdministrationManagementAPIAPI_Expecter) RemoveUser(ctx interface{}, id interface{}) *MockUserAdministrationManagementAPIAPI_RemoveUser_Call {
	return &MockUserAdministrationManagementAPIAPI_RemoveUser_Call{Call: _e.mock.On("RemoveUser", ctx, id)}
}

func (_c *MockUserAdministrationManagementAPIAPI_RemoveUser_Call) Run(run func(ctx context.Context, id string)) *MockUserAdministrationManagementAPIAPI_RemoveUser_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 *MockUserAdministrationManagementAPIAPI_RemoveUser_Call) Return(apiRemoveUserRequest client.ApiRemoveUserRequest) *MockUserAdministrationManagementAPIAPI_RemoveUser_Call {
	_c.Call.Return(apiRemoveUserRequest)
	return _c
}

func (_c *MockUserAdministrationManagementAPIAPI_RemoveUser_Call) RunAndReturn(run func(ctx context.Context, id string) client.ApiRemoveUserRequest) *MockUserAdministrationManagementAPIAPI_RemoveUser_Call {
	_c.Call.Return(run)
	return _c
}

// RemoveUserExecute provides a mock function for the type MockUserAdministrationManagementAPIAPI
func (_mock *MockUserAdministrationManagementAPIAPI) RemoveUserExecute(r client.ApiRemoveUserRequest) (*http.Response, error) {
	ret := _mock.Called(r)

	if len(ret) == 0 {
		panic("no return value specified for RemoveUserExecute")
	}

	var r0 *http.Response
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(client.ApiRemoveUserRequest) (*http.Response, error)); ok {
		return returnFunc(r)
	}
	if returnFunc, ok := ret.Get(0).(func(client.ApiRemoveUserRequest) *http.Response); ok {
		r0 = returnFunc(r)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*http.Response)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(client.ApiRemoveUserRequest) error); ok {
		r1 = returnFunc(r)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// MockUserAdministrationManagementAPIAPI_RemoveUserExecute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RemoveUserExecute'
type MockUserAdministrationManagementAPIAPI_RemoveUserExecute_Call struct {
	*mock.Call
}

// RemoveUserExecute is a helper method to define mock.On call
//   - r client.ApiRemoveUserRequest
func (_e *MockUserAdministrationManagementAPIAPI_Expecter) RemoveUserExecute(r interface{}) *MockUserAdministrationManagementAPIAPI_RemoveUserExecute_Call {
	return &MockUserAdministrationManagementAPIAPI_RemoveUserExecute_Call{Call: _e.mock.On("RemoveUserExecute", r)}
}

func (_c *MockUserAdministrationManagementAPIAPI_RemoveUserExecute_Call) Run(run func(r client.ApiRemoveUserRequest)) *MockUserAdministrationManagementAPIAPI_RemoveUserExecute_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 client.ApiRemoveUserRequest
		if args[0] != nil {
			arg0 = args[0].(client.ApiRemoveUserRequest)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *MockUserAdministrationManagementAPIAPI_RemoveUserExecute_Call) Return(response *http.Response, err error) *MockUserAdministrationManagementAPIAPI_RemoveUserExecute_Call {
	_c.Call.Return(response, err)
	return _c
}

func (_c *MockUserAdministrationManagementAPIAPI_RemoveUserExecute_Call) RunAndReturn(run func(r client.ApiRemoveUserRequest) (*http.Response, error)) *MockUserAdministrationManagementAPIAPI_RemoveUserExecute_Call {
	_c.Call.Return(run)
	return _c
}

// RevokePersonalAccessToken provides a mock function for the type MockUserAdministrationManagementAPIAPI
func (_mock *MockUserAdministrationManagementAPIAPI) RevokePersonalAccessToken(ctx context.Context, id string) client.ApiRevokePersonalAccessTokenRequest {
	ret := _mock.Called(ctx, id)

	if len(ret) == 0 {
		panic("no return value specified for RevokePersonalAccessToken")
	}

	var r0 client.ApiRevokePersonalAccessTokenRequest
	if returnFunc, ok := ret.Get(0).(func(context.Context, string) client.ApiRevokePersonalAccessTokenRequest); ok {
		r0 = returnFunc(ctx, id)
	} else {
		r0 = ret.Get(0).(client.ApiRevokePersonalAccessTokenRequest)
	}
	return r0
}

// MockUserAdministrationManagementAPIAPI_RevokePersonalAccessToken_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RevokePersonalAccessToken'
type MockUserAdministrationManagementAPIAPI_RevokePersonalAccessToken_Call struct {
	*mock.Call
}

// RevokePersonalAccessToken is a helper method to define mock.On call
//   - ctx context.Context
//   - id string
func (_e *MockUserAdministrationManagementAPIAPI_Expecter) RevokePersonalAccessToken(ctx interface{}, id interface{}) *MockUserAdministrationManagementAPIAPI_RevokePersonalAccessToken_Call {
	return &MockUserAdministrationManagementAPIAPI_RevokePersonalAccessToken_Call{Call: _e.mock.On("RevokePersonalAccessToken", ctx, id)}
}

func (_c *MockUserAdministrationManagementAPIAPI_RevokePersonalAccessToken_Call) Run(run func(ctx context.Context, id string)) *MockUserAdministrationManagementAPIAPI_RevokePersonalAccessToken_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 *MockUserAdministrationManagementAPIAPI_RevokePersonalAccessToken_Call) Return(apiRevokePersonalAccessTokenRequest client.ApiRevokePersonalAccessTokenRequest) *MockUserAdministrationManagementAPIAPI_RevokePersonalAccessToken_Call {
	_c.Call.Return(apiRevokePersonalAccessTokenRequest)
	return _c
}

func (_c *MockUserAdministrationManagementAPIAPI_RevokePersonalAccessToken_Call) RunAndReturn(run func(ctx context.Context, id string) client.ApiRevokePersonalAccessTokenRequest) *MockUserAdministrationManagementAPIAPI_RevokePersonalAccessToken_Call {
	_c.Call.Return(run)
	return _c
}

// RevokePersonalAccessTokenExecute provides a mock function for the type MockUserAdministrationManagementAPIAPI
func (_mock *MockUserAdministrationManagementAPIAPI) RevokePersonalAccessTokenExecute(r client.ApiRevokePersonalAccessTokenRequest) (*http.Response, error) {
	ret := _mock.Called(r)

	if len(ret) == 0 {
		panic("no return value specified for RevokePersonalAccessTokenExecute")
	}

	var r0 *http.Response
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(client.ApiRevokePersonalAccessTokenRequest) (*http.Response, error)); ok {
		return returnFunc(r)
	}
	if returnFunc, ok := ret.Get(0).(func(client.ApiRevokePersonalAccessTokenRequest) *http.Response); ok {
		r0 = returnFunc(r)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*http.Response)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(client.ApiRevokePersonalAccessTokenRequest) error); ok {
		r1 = returnFunc(r)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// MockUserAdministrationManagementAPIAPI_RevokePersonalAccessTokenExecute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RevokePersonalAccessTokenExecute'
type MockUserAdministrationManagementAPIAPI_RevokePersonalAccessTokenExecute_Call struct {
	*mock.Call
}

// RevokePersonalAccessTokenExecute is a helper method to define mock.On call
//   - r client.ApiRevokePersonalAccessTokenRequest
func (_e *MockUserAdministrationManagementAPIAPI_Expecter) RevokePersonalAccessTokenExecute(r interface{}) *MockUserAdministrationManagementAPIAPI_RevokePersonalAccessTokenExecute_Call {
	return &MockUserAdministrationManagementAPIAPI_RevokePersonalAccessTokenExecute_Call{Call: _e.mock.On("RevokePersonalAccessTokenExecute", r)}
}

func (_c *MockUserAdministrationManagementAPIAPI_RevokePersonalAccessTokenExecute_Call) Run(run func(r client.ApiRevokePersonalAccessTokenRequest)) *MockUserAdministrationManagementAPIAPI_RevokePersonalAccessTokenExecute_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 client.ApiRevokePersonalAccessTokenRequest
		if args[0] != nil {
			arg0 = args[0].(client.ApiRevokePersonalAccessTokenRequest)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *MockUserAdministrationManagementAPIAPI_RevokePersonalAccessTokenExecute_Call) Return(response *http.Response, err error) *MockUserAdministrationManagementAPIAPI_RevokePersonalAccessTokenExecute_Call {
	_c.Call.Return(response, err)
	return _c
}

func (_c *MockUserAdministrationManagementAPIAPI_RevokePersonalAccessTokenExecute_Call) RunAndReturn(run func(r client.ApiRevokePersonalAccessTokenRequest) (*http.Response, error)) *MockUserAdministrationManagementAPIAPI_RevokePersonalAccessTokenExecute_Call {
	_c.Call.Return(run)
	return _c
}

// ShowMyUserSettings provides a mock function for the type MockUserAdministrationManagementAPIAPI
func (_mock *MockUserAdministrationManagementAPIAPI) ShowMyUserSettings(ctx context.Context) client.ApiShowMyUserSettingsRequest {
	ret := _mock.Called(ctx)

	if len(ret) == 0 {
		panic("no return value specified for ShowMyUserSettings")
	}

	var r0 client.ApiShowMyUserSettingsRequest
	if returnFunc, ok := ret.Get(0).(func(context.Context) client.ApiShowMyUserSettingsRequest); ok {
		r0 = returnFunc(ctx)
	} else {
		r0 = ret.Get(0).(client.ApiShowMyUserSettingsRequest)
	}
	return r0
}

// MockUserAdministrationManagementAPIAPI_ShowMyUserSettings_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ShowMyUserSettings'
type MockUserAdministrationManagementAPIAPI_ShowMyUserSettings_Call struct {
	*mock.Call
}

// ShowMyUserSettings is a helper method to define mock.On call
//   - ctx context.Context
func (_e *MockUserAdministrationManagementAPIAPI_Expecter) ShowMyUserSettings(ctx interface{}) *MockUserAdministrationManagementAPIAPI_ShowMyUserSettings_Call {
	return &MockUserAdministrationManagementAPIAPI_ShowMyUserSettings_Call{Call: _e.mock.On("ShowMyUserSettings", ctx)}
}

func (_c *MockUserAdministrationManagementAPIAPI_ShowMyUserSettings_Call) Run(run func(ctx context.Context)) *MockUserAdministrationManagementAPIAPI_ShowMyUserSettings_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *MockUserAdministrationManagementAPIAPI_ShowMyUserSettings_Call) Return(apiShowMyUserSettingsRequest client.ApiShowMyUserSettingsRequest) *MockUserAdministrationManagementAPIAPI_ShowMyUserSettings_Call {
	_c.Call.Return(apiShowMyUserSettingsRequest)
	return _c
}

func (_c *MockUserAdministrationManagementAPIAPI_ShowMyUserSettings_Call) RunAndReturn(run func(ctx context.Context) client.ApiShowMyUserSettingsRequest) *MockUserAdministrationManagementAPIAPI_ShowMyUserSettings_Call {
	_c.Call.Return(run)
	return _c
}

// ShowMyUserSettingsExecute provides a mock function for the type MockUserAdministrationManagementAPIAPI
func (_mock *MockUserAdministrationManagementAPIAPI) ShowMyUserSettingsExecute(r client.ApiShowMyUserSettingsRequest) (map[string]interface{}, *http.Response, error) {
	ret := _mock.Called(r)

	if len(ret) == 0 {
		panic("no return value specified for ShowMyUserSettingsExecute")
	}

	var r0 map[string]interface{}
	var r1 *http.Response
	var r2 error
	if returnFunc, ok := ret.Get(0).(func(client.ApiShowMyUserSettingsRequest) (map[string]interface{}, *http.Response, error)); ok {
		return returnFunc(r)
	}
	if returnFunc, ok := ret.Get(0).(func(client.ApiShowMyUserSettingsRequest) map[string]interface{}); ok {
		r0 = returnFunc(r)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(map[string]interface{})
		}
	}
	if returnFunc, ok := ret.Get(1).(func(client.ApiShowMyUserSettingsRequest) *http.Response); ok {
		r1 = returnFunc(r)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*http.Response)
		}
	}
	if returnFunc, ok := ret.Get(2).(func(client.ApiShowMyUserSettingsRequest) error); ok {
		r2 = returnFunc(r)
	} else {
		r2 = ret.Error(2)
	}
	return r0, r1, r2
}

// MockUserAdministrationManagementAPIAPI_ShowMyUserSettingsExecute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ShowMyUserSettingsExecute'
type MockUserAdministrationManagementAPIAPI_ShowMyUserSettingsExecute_Call struct {
	*mock.Call
}

// ShowMyUserSettingsExecute is a helper method to define mock.On call
//   - r client.ApiShowMyUserSettingsRequest
func (_e *MockUserAdministrationManagementAPIAPI_Expecter) ShowMyUserSettingsExecute(r interface{}) *MockUserAdministrationManagementAPIAPI_ShowMyUserSettingsExecute_Call {
	return &MockUserAdministrationManagementAPIAPI_ShowMyUserSettingsExecute_Call{Call: _e.mock.On("ShowMyUserSettingsExecute", r)}
}

func (_c *MockUserAdministrationManagementAPIAPI_ShowMyUserSettingsExecute_Call) Run(run func(r client.ApiShowMyUserSettingsRequest)) *MockUserAdministrationManagementAPIAPI_ShowMyUserSettingsExecute_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 client.ApiShowMyUserSettingsRequest
		if args[0] != nil {
			arg0 = args[0].(client.ApiShowMyUserSettingsRequest)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *MockUserAdministrationManagementAPIAPI_ShowMyUserSettingsExecute_Call) Return(stringToIfaceVal map[string]interface{}, response *http.Response, err error) *MockUserAdministrationManagementAPIAPI_ShowMyUserSettingsExecute_Call {
	_c.Call.Return(stringToIfaceVal, response, err)
	return _c
}

func (_c *MockUserAdministrationManagementAPIAPI_ShowMyUserSettingsExecute_Call) RunAndReturn(run func(r client.ApiShowMyUserSettingsRequest) (map[string]interface{}, *http.Response, error)) *MockUserAdministrationManagementAPIAPI_ShowMyUserSettingsExecute_Call {
	_c.Call.Return(run)
	return _c
}

// ShowOwnUserData provides a mock function for the type MockUserAdministrationManagementAPIAPI
func (_mock *MockUserAdministrationManagementAPIAPI) ShowOwnUserData(ctx context.Context) client.ApiShowOwnUserDataRequest {
	ret := _mock.Called(ctx)

	if len(ret) == 0 {
		panic("no return value specified for ShowOwnUserData")
	}

	var r0 client.ApiShowOwnUserDataRequest
	if returnFunc, ok := ret.Get(0).(func(context.Context) client.ApiShowOwnUserDataRequest); ok {
		r0 = returnFunc(ctx)
	} else {
		r0 = ret.Get(0).(client.ApiShowOwnUserDataRequest)
	}
	return r0
}

// MockUserAdministrationManagementAPIAPI_ShowOwnUserData_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ShowOwnUserData'
type MockUserAdministrationManagementAPIAPI_ShowOwnUserData_Call struct {
	*mock.Call
}

// ShowOwnUserData is a helper method to define mock.On call
//   - ctx context.Context
func (_e *MockUserAdministrationManagementAPIAPI_Expecter) ShowOwnUserData(ctx interface{}) *MockUserAdministrationManagementAPIAPI_ShowOwnUserData_Call {
	return &MockUserAdministrationManagementAPIAPI_ShowOwnUserData_Call{Call: _e.mock.On("ShowOwnUserData", ctx)}
}

func (_c *MockUserAdministrationManagementAPIAPI_ShowOwnUserData_Call) Run(run func(ctx context.Context)) *MockUserAdministrationManagementAPIAPI_ShowOwnUserData_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *MockUserAdministrationManagementAPIAPI_ShowOwnUserData_Call) Return(apiShowOwnUserDataRequest client.ApiShowOwnUserDataRequest) *MockUserAdministrationManagementAPIAPI_ShowOwnUserData_Call {
	_c.Call.Return(apiShowOwnUserDataRequest)
	return _c
}

func (_c *MockUserAdministrationManagementAPIAPI_ShowOwnUserData_Call) RunAndReturn(run func(ctx context.Context) client.ApiShowOwnUserDataRequest) *MockUserAdministrationManagementAPIAPI_ShowOwnUserData_Call {
	_c.Call.Return(run)
	return _c
}

// ShowOwnUserDataExecute provides a mock function for the type MockUserAdministrationManagementAPIAPI
func (_mock *MockUserAdministrationManagementAPIAPI) ShowOwnUserDataExecute(r client.ApiShowOwnUserDataRequest) (*client.User, *http.Response, error) {
	ret := _mock.Called(r)

	if len(ret) == 0 {
		panic("no return value specified for ShowOwnUserDataExecute")
	}

	var r0 *client.User
	var r1 *http.Response
	var r2 error
	if returnFunc, ok := ret.Get(0).(func(client.ApiShowOwnUserDataRequest) (*client.User, *http.Response, error)); ok {
		return returnFunc(r)
	}
	if returnFunc, ok := ret.Get(0).(func(client.ApiShowOwnUserDataRequest) *client.User); ok {
		r0 = returnFunc(r)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*client.User)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(client.ApiShowOwnUserDataRequest) *http.Response); ok {
		r1 = returnFunc(r)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*http.Response)
		}
	}
	if returnFunc, ok := ret.Get(2).(func(client.ApiShowOwnUserDataRequest) error); ok {
		r2 = returnFunc(r)
	} else {
		r2 = ret.Error(2)
	}
	return r0, r1, r2
}

// MockUserAdministrationManagementAPIAPI_ShowOwnUserDataExecute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ShowOwnUserDataExecute'
type MockUserAdministrationManagementAPIAPI_ShowOwnUserDataExecute_Call struct {
	*mock.Call
}

// ShowOwnUserDataExecute is a helper method to define mock.On call
//   - r client.ApiShowOwnUserDataRequest
func (_e *MockUserAdministrationManagementAPIAPI_Expecter) ShowOwnUserDataExecute(r interface{}) *MockUserAdministrationManagementAPIAPI_ShowOwnUserDataExecute_Call {
	return &MockUserAdministrationManagementAPIAPI_ShowOwnUserDataExecute_Call{Call: _e.mock.On("ShowOwnUserDataExecute", r)}
}

func (_c *MockUserAdministrationManagementAPIAPI_ShowOwnUserDataExecute_Call) Run(run func(r client.ApiShowOwnUserDataRequest)) *MockUserAdministrationManagementAPIAPI_ShowOwnUserDataExecute_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 client.ApiShowOwnUserDataRequest
		if args[0] != nil {
			arg0 = args[0].(client.ApiShowOwnUserDataRequest)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *MockUserAdministrationManagementAPIAPI_ShowOwnUserDataExecute_Call) Return(user *client.User, response *http.Response, err error) *MockUserAdministrationManagementAPIAPI_ShowOwnUserDataExecute_Call {
	_c.Call.Return(user, response, err)
	return _c
}

func (_c *MockUserAdministrationManagementAPIAPI_ShowOwnUserDataExecute_Call) RunAndReturn(run func(r client.ApiShowOwnUserDataRequest) (*client.User, *http.Response, error)) *MockUserAdministrationManagementAPIAPI_ShowOwnUserDataExecute_Call {
	_c.Call.Return(run)
	return _c
}

// ShowPlanAndLimits provides a mock function for the type MockUserAdministrationManagementAPIAPI
func (_mock *MockUserAdministrationManagementAPIAPI) ShowPlanAndLimits(ctx context.Context) client.ApiShowPlanAndLimitsRequest {
	ret := _mock.Called(ctx)

	if len(ret) == 0 {
		panic("no return value specified for ShowPlanAndLimits")
	}

	var r0 client.ApiShowPlanAndLimitsRequest
	if returnFunc, ok := ret.Get(0).(func(context.Context) client.ApiShowPlanAndLimitsRequest); ok {
		r0 = returnFunc(ctx)
	} else {
		r0 = ret.Get(0).(client.ApiShowPlanAndLimitsRequest)
	}
	return r0
}

// MockUserAdministrationManagementAPIAPI_ShowPlanAndLimits_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ShowPlanAndLimits'
type MockUserAdministrationManagementAPIAPI_ShowPlanAndLimits_Call struct {
	*mock.Call
}

// ShowPlanAndLimits is a helper method to define mock.On call
//   - ctx context.Context
func (_e *MockUserAdministrationManagementAPIAPI_Expecter) ShowPlanAndLimits(ctx interface{}) *MockUserAdministrationManagementAPIAPI_ShowPlanAndLimits_Call {
	return &MockUserAdministrationManagementAPIAPI_ShowPlanAndLimits_Call{Call: _e.mock.On("ShowPlanAndLimits", ctx)}
}

func (_c *MockUserAdministrationManagementAPIAPI_ShowPlanAndLimits_Call) Run(run func(ctx context.Context)) *MockUserAdministrationManagementAPIAPI_ShowPlanAndLimits_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *MockUserAdministrationManagementAPIAPI_ShowPlanAndLimits_Call) Return(apiShowPlanAndLimitsRequest client.ApiShowPlanAndLimitsRequest) *MockUserAdministrationManagementAPIAPI_ShowPlanAndLimits_Call {
	_c.Call.Return(apiShowPlanAndLimitsRequest)
	return _c
}

func (_c *MockUserAdministrationManagementAPIAPI_ShowPlanAndLimits_Call) RunAndReturn(run func(ctx context.Context) client.ApiShowPlanAndLimitsRequest) *MockUserAdministrationManagementAPIAPI_ShowPlanAndLimits_Call {
	_c.Call.Return(run)
	return _c
}

// ShowPlanAndLimitsExecute provides a mock function for the type MockUserAdministrationManagementAPIAPI
func (_mock *MockUserAdministrationManagementAPIAPI) ShowPlanAndLimitsExecute(r client.ApiShowPlanAndLimitsRequest) (*client.PlanBindingDetails, *http.Response, error) {
	ret := _mock.Called(r)

	if len(ret) == 0 {
		panic("no return value specified for ShowPlanAndLimitsExecute")
	}

	var r0 *client.PlanBindingDetails
	var r1 *http.Response
	var r2 error
	if returnFunc, ok := ret.Get(0).(func(client.ApiShowPlanAndLimitsRequest) (*client.PlanBindingDetails, *http.Response, error)); ok {
		return returnFunc(r)
	}
	if returnFunc, ok := ret.Get(0).(func(client.ApiShowPlanAndLimitsRequest) *client.PlanBindingDetails); ok {
		r0 = returnFunc(r)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*client.PlanBindingDetails)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(client.ApiShowPlanAndLimitsRequest) *http.Response); ok {
		r1 = returnFunc(r)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*http.Response)
		}
	}
	if returnFunc, ok := ret.Get(2).(func(client.ApiShowPlanAndLimitsRequest) error); ok {
		r2 = returnFunc(r)
	} else {
		r2 = ret.Error(2)
	}
	return r0, r1, r2
}

// MockUserAdministrationManagementAPIAPI_ShowPlanAndLimitsExecute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ShowPlanAndLimitsExecute'
type MockUserAdministrationManagementAPIAPI_ShowPlanAndLimitsExecute_Call struct {
	*mock.Call
}

// ShowPlanAndLimitsExecute is a helper method to define mock.On call
//   - r client.ApiShowPlanAndLimitsRequest
func (_e *MockUserAdministrationManagementAPIAPI_Expecter) ShowPlanAndLimitsExecute(r interface{}) *MockUserAdministrationManagementAPIAPI_ShowPlanAndLimitsExecute_Call {
	return &MockUserAdministrationManagementAPIAPI_ShowPlanAndLimitsExecute_Call{Call: _e.mock.On("ShowPlanAndLimitsExecute", r)}
}

func (_c *MockUserAdministrationManagementAPIAPI_ShowPlanAndLimitsExecute_Call) Run(run func(r client.ApiShowPlanAndLimitsRequest)) *MockUserAdministrationManagementAPIAPI_ShowPlanAndLimitsExecute_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 client.ApiShowPlanAndLimitsRequest
		if args[0] != nil {
			arg0 = args[0].(client.ApiShowPlanAndLimitsRequest)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *MockUserAdministrationManagementAPIAPI_ShowPlanAndLimitsExecute_Call) Return(planBindingDetails *client.PlanBindingDetails, response *http.Response, err error) *MockUserAdministrationManagementAPIAPI_ShowPlanAndLimitsExecute_Call {
	_c.Call.Return(planBindingDetails, response, err)
	return _c
}

func (_c *MockUserAdministrationManagementAPIAPI_ShowPlanAndLimitsExecute_Call) RunAndReturn(run func(r client.ApiShowPlanAndLimitsRequest) (*client.PlanBindingDetails, *http.Response, error)) *MockUserAdministrationManagementAPIAPI_ShowPlanAndLimitsExecute_Call {
	_c.Call.Return(run)
	return _c
}

// ShowUser provides a mock function for the type MockUserAdministrationManagementAPIAPI
func (_mock *MockUserAdministrationManagementAPIAPI) ShowUser(ctx context.Context, id string) client.ApiShowUserRequest {
	ret := _mock.Called(ctx, id)

	if len(ret) == 0 {
		panic("no return value specified for ShowUser")
	}

	var r0 client.ApiShowUserRequest
	if returnFunc, ok := ret.Get(0).(func(context.Context, string) client.ApiShowUserRequest); ok {
		r0 = returnFunc(ctx, id)
	} else {
		r0 = ret.Get(0).(client.ApiShowUserRequest)
	}
	return r0
}

// MockUserAdministrationManagementAPIAPI_ShowUser_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ShowUser'
type MockUserAdministrationManagementAPIAPI_ShowUser_Call struct {
	*mock.Call
}

// ShowUser is a helper method to define mock.On call
//   - ctx context.Context
//   - id string
func (_e *MockUserAdministrationManagementAPIAPI_Expecter) ShowUser(ctx interface{}, id interface{}) *MockUserAdministrationManagementAPIAPI_ShowUser_Call {
	return &MockUserAdministrationManagementAPIAPI_ShowUser_Call{Call: _e.mock.On("ShowUser", ctx, id)}
}

func (_c *MockUserAdministrationManagementAPIAPI_ShowUser_Call) Run(run func(ctx context.Context, id string)) *MockUserAdministrationManagementAPIAPI_ShowUser_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 *MockUserAdministrationManagementAPIAPI_ShowUser_Call) Return(apiShowUserRequest client.ApiShowUserRequest) *MockUserAdministrationManagementAPIAPI_ShowUser_Call {
	_c.Call.Return(apiShowUserRequest)
	return _c
}

func (_c *MockUserAdministrationManagementAPIAPI_ShowUser_Call) RunAndReturn(run func(ctx context.Context, id string) client.ApiShowUserRequest) *MockUserAdministrationManagementAPIAPI_ShowUser_Call {
	_c.Call.Return(run)
	return _c
}

// ShowUserExecute provides a mock function for the type MockUserAdministrationManagementAPIAPI
func (_mock *MockUserAdministrationManagementAPIAPI) ShowUserExecute(r client.ApiShowUserRequest) (*client.User, *http.Response, error) {
	ret := _mock.Called(r)

	if len(ret) == 0 {
		panic("no return value specified for ShowUserExecute")
	}

	var r0 *client.User
	var r1 *http.Response
	var r2 error
	if returnFunc, ok := ret.Get(0).(func(client.ApiShowUserRequest) (*client.User, *http.Response, error)); ok {
		return returnFunc(r)
	}
	if returnFunc, ok := ret.Get(0).(func(client.ApiShowUserRequest) *client.User); ok {
		r0 = returnFunc(r)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*client.User)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(client.ApiShowUserRequest) *http.Response); ok {
		r1 = returnFunc(r)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*http.Response)
		}
	}
	if returnFunc, ok := ret.Get(2).(func(client.ApiShowUserRequest) error); ok {
		r2 = returnFunc(r)
	} else {
		r2 = ret.Error(2)
	}
	return r0, r1, r2
}

// MockUserAdministrationManagementAPIAPI_ShowUserExecute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ShowUserExecute'
type MockUserAdministrationManagementAPIAPI_ShowUserExecute_Call struct {
	*mock.Call
}

// ShowUserExecute is a helper method to define mock.On call
//   - r client.ApiShowUserRequest
func (_e *MockUserAdministrationManagementAPIAPI_Expecter) ShowUserExecute(r interface{}) *MockUserAdministrationManagementAPIAPI_ShowUserExecute_Call {
	return &MockUserAdministrationManagementAPIAPI_ShowUserExecute_Call{Call: _e.mock.On("ShowUserExecute", r)}
}

func (_c *MockUserAdministrationManagementAPIAPI_ShowUserExecute_Call) Run(run func(r client.ApiShowUserRequest)) *MockUserAdministrationManagementAPIAPI_ShowUserExecute_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 client.ApiShowUserRequest
		if args[0] != nil {
			arg0 = args[0].(client.ApiShowUserRequest)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *MockUserAdministrationManagementAPIAPI_ShowUserExecute_Call) Return(user *client.User, response *http.Response, err error) *MockUserAdministrationManagementAPIAPI_ShowUserExecute_Call {
	_c.Call.Return(user, response, err)
	return _c
}

func (_c *MockUserAdministrationManagementAPIAPI_ShowUserExecute_Call) RunAndReturn(run func(r client.ApiShowUserRequest) (*client.User, *http.Response, error)) *MockUserAdministrationManagementAPIAPI_ShowUserExecute_Call {
	_c.Call.Return(run)
	return _c
}

// ShowUserSettings provides a mock function for the type MockUserAdministrationManagementAPIAPI
func (_mock *MockUserAdministrationManagementAPIAPI) ShowUserSettings(ctx context.Context) client.ApiShowUserSettingsRequest {
	ret := _mock.Called(ctx)

	if len(ret) == 0 {
		panic("no return value specified for ShowUserSettings")
	}

	var r0 client.ApiShowUserSettingsRequest
	if returnFunc, ok := ret.Get(0).(func(context.Context) client.ApiShowUserSettingsRequest); ok {
		r0 = returnFunc(ctx)
	} else {
		r0 = ret.Get(0).(client.ApiShowUserSettingsRequest)
	}
	return r0
}

// MockUserAdministrationManagementAPIAPI_ShowUserSettings_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ShowUserSettings'
type MockUserAdministrationManagementAPIAPI_ShowUserSettings_Call struct {
	*mock.Call
}

// ShowUserSettings is a helper method to define mock.On call
//   - ctx context.Context
func (_e *MockUserAdministrationManagementAPIAPI_Expecter) ShowUserSettings(ctx interface{}) *MockUserAdministrationManagementAPIAPI_ShowUserSettings_Call {
	return &MockUserAdministrationManagementAPIAPI_ShowUserSettings_Call{Call: _e.mock.On("ShowUserSettings", ctx)}
}

func (_c *MockUserAdministrationManagementAPIAPI_ShowUserSettings_Call) Run(run func(ctx context.Context)) *MockUserAdministrationManagementAPIAPI_ShowUserSettings_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *MockUserAdministrationManagementAPIAPI_ShowUserSettings_Call) Return(apiShowUserSettingsRequest client.ApiShowUserSettingsRequest) *MockUserAdministrationManagementAPIAPI_ShowUserSettings_Call {
	_c.Call.Return(apiShowUserSettingsRequest)
	return _c
}

func (_c *MockUserAdministrationManagementAPIAPI_ShowUserSettings_Call) RunAndReturn(run func(ctx context.Context) client.ApiShowUserSettingsRequest) *MockUserAdministrationManagementAPIAPI_ShowUserSettings_Call {
	_c.Call.Return(run)
	return _c
}

// ShowUserSettingsExecute provides a mock function for the type MockUserAdministrationManagementAPIAPI
func (_mock *MockUserAdministrationManagementAPIAPI) ShowUserSettingsExecute(r client.ApiShowUserSettingsRequest) (map[string]interface{}, *http.Response, error) {
	ret := _mock.Called(r)

	if len(ret) == 0 {
		panic("no return value specified for ShowUserSettingsExecute")
	}

	var r0 map[string]interface{}
	var r1 *http.Response
	var r2 error
	if returnFunc, ok := ret.Get(0).(func(client.ApiShowUserSettingsRequest) (map[string]interface{}, *http.Response, error)); ok {
		return returnFunc(r)
	}
	if returnFunc, ok := ret.Get(0).(func(client.ApiShowUserSettingsRequest) map[string]interface{}); ok {
		r0 = returnFunc(r)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(map[string]interface{})
		}
	}
	if returnFunc, ok := ret.Get(1).(func(client.ApiShowUserSettingsRequest) *http.Response); ok {
		r1 = returnFunc(r)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*http.Response)
		}
	}
	if returnFunc, ok := ret.Get(2).(func(client.ApiShowUserSettingsRequest) error); ok {
		r2 = returnFunc(r)
	} else {
		r2 = ret.Error(2)
	}
	return r0, r1, r2
}

// MockUserAdministrationManagementAPIAPI_ShowUserSettingsExecute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ShowUserSettingsExecute'
type MockUserAdministrationManagementAPIAPI_ShowUserSettingsExecute_Call struct {
	*mock.Call
}

// ShowUserSettingsExecute is a helper method to define mock.On call
//   - r client.ApiShowUserSettingsRequest
func (_e *MockUserAdministrationManagementAPIAPI_Expecter) ShowUserSettingsExecute(r interface{}) *MockUserAdministrationManagementAPIAPI_ShowUserSettingsExecute_Call {
	return &MockUserAdministrationManagementAPIAPI_ShowUserSettingsExecute_Call{Call: _e.mock.On("ShowUserSettingsExecute", r)}
}

func (_c *MockUserAdministrationManagementAPIAPI_ShowUserSettingsExecute_Call) Run(run func(r client.ApiShowUserSettingsRequest)) *MockUserAdministrationManagementAPIAPI_ShowUserSettingsExecute_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 client.ApiShowUserSettingsRequest
		if args[0] != nil {
			arg0 = args[0].(client.ApiShowUserSettingsRequest)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *MockUserAdministrationManagementAPIAPI_ShowUserSettingsExecute_Call) Return(stringToIfaceVal map[string]interface{}, response *http.Response, err error) *MockUserAdministrationManagementAPIAPI_ShowUserSettingsExecute_Call {
	_c.Call.Return(stringToIfaceVal, response, err)
	return _c
}

func (_c *MockUserAdministrationManagementAPIAPI_ShowUserSettingsExecute_Call) RunAndReturn(run func(r client.ApiShowUserSettingsRequest) (map[string]interface{}, *http.Response, error)) *MockUserAdministrationManagementAPIAPI_ShowUserSettingsExecute_Call {
	_c.Call.Return(run)
	return _c
}

// UpdateMyUserSettings provides a mock function for the type MockUserAdministrationManagementAPIAPI
func (_mock *MockUserAdministrationManagementAPIAPI) UpdateMyUserSettings(ctx context.Context) client.ApiUpdateMyUserSettingsRequest {
	ret := _mock.Called(ctx)

	if len(ret) == 0 {
		panic("no return value specified for UpdateMyUserSettings")
	}

	var r0 client.ApiUpdateMyUserSettingsRequest
	if returnFunc, ok := ret.Get(0).(func(context.Context) client.ApiUpdateMyUserSettingsRequest); ok {
		r0 = returnFunc(ctx)
	} else {
		r0 = ret.Get(0).(client.ApiUpdateMyUserSettingsRequest)
	}
	return r0
}

// MockUserAdministrationManagementAPIAPI_UpdateMyUserSettings_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdateMyUserSettings'
type MockUserAdministrationManagementAPIAPI_UpdateMyUserSettings_Call struct {
	*mock.Call
}

// UpdateMyUserSettings is a helper method to define mock.On call
//   - ctx context.Context
func (_e *MockUserAdministrationManagementAPIAPI_Expecter) UpdateMyUserSettings(ctx interface{}) *MockUserAdministrationManagementAPIAPI_UpdateMyUserSettings_Call {
	return &MockUserAdministrationManagementAPIAPI_UpdateMyUserSettings_Call{Call: _e.mock.On("UpdateMyUserSettings", ctx)}
}

func (_c *MockUserAdministrationManagementAPIAPI_UpdateMyUserSettings_Call) Run(run func(ctx context.Context)) *MockUserAdministrationManagementAPIAPI_UpdateMyUserSettings_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *MockUserAdministrationManagementAPIAPI_UpdateMyUserSettings_Call) Return(apiUpdateMyUserSettingsRequest client.ApiUpdateMyUserSettingsRequest) *MockUserAdministrationManagementAPIAPI_UpdateMyUserSettings_Call {
	_c.Call.Return(apiUpdateMyUserSettingsRequest)
	return _c
}

func (_c *MockUserAdministrationManagementAPIAPI_UpdateMyUserSettings_Call) RunAndReturn(run func(ctx context.Context) client.ApiUpdateMyUserSettingsRequest) *MockUserAdministrationManagementAPIAPI_UpdateMyUserSettings_Call {
	_c.Call.Return(run)
	return _c
}

// UpdateMyUserSettingsExecute provides a mock function for the type MockUserAdministrationManagementAPIAPI
func (_mock *MockUserAdministrationManagementAPIAPI) UpdateMyUserSettingsExecute(r client.ApiUpdateMyUserSettingsRequest) (*http.Response, error) {
	ret := _mock.Called(r)

	if len(ret) == 0 {
		panic("no return value specified for UpdateMyUserSettingsExecute")
	}

	var r0 *http.Response
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(client.ApiUpdateMyUserSettingsRequest) (*http.Response, error)); ok {
		return returnFunc(r)
	}
	if returnFunc, ok := ret.Get(0).(func(client.ApiUpdateMyUserSettingsRequest) *http.Response); ok {
		r0 = returnFunc(r)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*http.Response)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(client.ApiUpdateMyUserSettingsRequest) error); ok {
		r1 = returnFunc(r)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// MockUserAdministrationManagementAPIAPI_UpdateMyUserSettingsExecute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdateMyUserSettingsExecute'
type MockUserAdministrationManagementAPIAPI_UpdateMyUserSettingsExecute_Call struct {
	*mock.Call
}

// UpdateMyUserSettingsExecute is a helper method to define mock.On call
//   - r client.ApiUpdateMyUserSettingsRequest
func (_e *MockUserAdministrationManagementAPIAPI_Expecter) UpdateMyUserSettingsExecute(r interface{}) *MockUserAdministrationManagementAPIAPI_UpdateMyUserSettingsExecute_Call {
	return &MockUserAdministrationManagementAPIAPI_UpdateMyUserSettingsExecute_Call{Call: _e.mock.On("UpdateMyUserSettingsExecute", r)}
}

func (_c *MockUserAdministrationManagementAPIAPI_UpdateMyUserSettingsExecute_Call) Run(run func(r client.ApiUpdateMyUserSettingsRequest)) *MockUserAdministrationManagementAPIAPI_UpdateMyUserSettingsExecute_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 client.ApiUpdateMyUserSettingsRequest
		if args[0] != nil {
			arg0 = args[0].(client.ApiUpdateMyUserSettingsRequest)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *MockUserAdministrationManagementAPIAPI_UpdateMyUserSettingsExecute_Call) Return(response *http.Response, err error) *MockUserAdministrationManagementAPIAPI_UpdateMyUserSettingsExecute_Call {
	_c.Call.Return(response, err)
	return _c
}

func (_c *MockUserAdministrationManagementAPIAPI_UpdateMyUserSettingsExecute_Call) RunAndReturn(run func(r client.ApiUpdateMyUserSettingsRequest) (*http.Response, error)) *MockUserAdministrationManagementAPIAPI_UpdateMyUserSettingsExecute_Call {
	_c.Call.Return(run)
	return _c
}

// UpdateOwnUserData provides a mock function for the type MockUserAdministrationManagementAPIAPI
func (_mock *MockUserAdministrationManagementAPIAPI) UpdateOwnUserData(ctx context.Context) client.ApiUpdateOwnUserDataRequest {
	ret := _mock.Called(ctx)

	if len(ret) == 0 {
		panic("no return value specified for UpdateOwnUserData")
	}

	var r0 client.ApiUpdateOwnUserDataRequest
	if returnFunc, ok := ret.Get(0).(func(context.Context) client.ApiUpdateOwnUserDataRequest); ok {
		r0 = returnFunc(ctx)
	} else {
		r0 = ret.Get(0).(client.ApiUpdateOwnUserDataRequest)
	}
	return r0
}

// MockUserAdministrationManagementAPIAPI_UpdateOwnUserData_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdateOwnUserData'
type MockUserAdministrationManagementAPIAPI_UpdateOwnUserData_Call struct {
	*mock.Call
}

// UpdateOwnUserData is a helper method to define mock.On call
//   - ctx context.Context
func (_e *MockUserAdministrationManagementAPIAPI_Expecter) UpdateOwnUserData(ctx interface{}) *MockUserAdministrationManagementAPIAPI_UpdateOwnUserData_Call {
	return &MockUserAdministrationManagementAPIAPI_UpdateOwnUserData_Call{Call: _e.mock.On("UpdateOwnUserData", ctx)}
}

func (_c *MockUserAdministrationManagementAPIAPI_UpdateOwnUserData_Call) Run(run func(ctx context.Context)) *MockUserAdministrationManagementAPIAPI_UpdateOwnUserData_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *MockUserAdministrationManagementAPIAPI_UpdateOwnUserData_Call) Return(apiUpdateOwnUserDataRequest client.ApiUpdateOwnUserDataRequest) *MockUserAdministrationManagementAPIAPI_UpdateOwnUserData_Call {
	_c.Call.Return(apiUpdateOwnUserDataRequest)
	return _c
}

func (_c *MockUserAdministrationManagementAPIAPI_UpdateOwnUserData_Call) RunAndReturn(run func(ctx context.Context) client.ApiUpdateOwnUserDataRequest) *MockUserAdministrationManagementAPIAPI_UpdateOwnUserData_Call {
	_c.Call.Return(run)
	return _c
}

// UpdateOwnUserDataExecute provides a mock function for the type MockUserAdministrationManagementAPIAPI
func (_mock *MockUserAdministrationManagementAPIAPI) UpdateOwnUserDataExecute(r client.ApiUpdateOwnUserDataRequest) (*http.Response, error) {
	ret := _mock.Called(r)

	if len(ret) == 0 {
		panic("no return value specified for UpdateOwnUserDataExecute")
	}

	var r0 *http.Response
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(client.ApiUpdateOwnUserDataRequest) (*http.Response, error)); ok {
		return returnFunc(r)
	}
	if returnFunc, ok := ret.Get(0).(func(client.ApiUpdateOwnUserDataRequest) *http.Response); ok {
		r0 = returnFunc(r)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*http.Response)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(client.ApiUpdateOwnUserDataRequest) error); ok {
		r1 = returnFunc(r)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// MockUserAdministrationManagementAPIAPI_UpdateOwnUserDataExecute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdateOwnUserDataExecute'
type MockUserAdministrationManagementAPIAPI_UpdateOwnUserDataExecute_Call struct {
	*mock.Call
}

// UpdateOwnUserDataExecute is a helper method to define mock.On call
//   - r client.ApiUpdateOwnUserDataRequest
func (_e *MockUserAdministrationManagementAPIAPI_Expecter) UpdateOwnUserDataExecute(r interface{}) *MockUserAdministrationManagementAPIAPI_UpdateOwnUserDataExecute_Call {
	return &MockUserAdministrationManagementAPIAPI_UpdateOwnUserDataExecute_Call{Call: _e.mock.On("UpdateOwnUserDataExecute", r)}
}

func (_c *MockUserAdministrationManagementAPIAPI_UpdateOwnUserDataExecute_Call) Run(run func(r client.ApiUpdateOwnUserDataRequest)) *MockUserAdministrationManagementAPIAPI_UpdateOwnUserDataExecute_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 client.ApiUpdateOwnUserDataRequest
		if args[0] != nil {
			arg0 = args[0].(client.ApiUpdateOwnUserDataRequest)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *MockUserAdministrationManagementAPIAPI_UpdateOwnUserDataExecute_Call) Return(response *http.Response, err error) *MockUserAdministrationManagementAPIAPI_UpdateOwnUserDataExecute_Call {
	_c.Call.Return(response, err)
	return _c
}

func (_c *MockUserAdministrationManagementAPIAPI_UpdateOwnUserDataExecute_Call) RunAndReturn(run func(r client.ApiUpdateOwnUserDataRequest) (*http.Response, error)) *MockUserAdministrationManagementAPIAPI_UpdateOwnUserDataExecute_Call {
	_c.Call.Return(run)
	return _c
}

// UpdateUser provides a mock function for the type MockUserAdministrationManagementAPIAPI
func (_mock *MockUserAdministrationManagementAPIAPI) UpdateUser(ctx context.Context, id string) client.ApiUpdateUserRequest {
	ret := _mock.Called(ctx, id)

	if len(ret) == 0 {
		panic("no return value specified for UpdateUser")
	}

	var r0 client.ApiUpdateUserRequest
	if returnFunc, ok := ret.Get(0).(func(context.Context, string) client.ApiUpdateUserRequest); ok {
		r0 = returnFunc(ctx, id)
	} else {
		r0 = ret.Get(0).(client.ApiUpdateUserRequest)
	}
	return r0
}

// MockUserAdministrationManagementAPIAPI_UpdateUser_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdateUser'
type MockUserAdministrationManagementAPIAPI_UpdateUser_Call struct {
	*mock.Call
}

// UpdateUser is a helper method to define mock.On call
//   - ctx context.Context
//   - id string
func (_e *MockUserAdministrationManagementAPIAPI_Expecter) UpdateUser(ctx interface{}, id interface{}) *MockUserAdministrationManagementAPIAPI_UpdateUser_Call {
	return &MockUserAdministrationManagementAPIAPI_UpdateUser_Call{Call: _e.mock.On("UpdateUser", ctx, id)}
}

func (_c *MockUserAdministrationManagementAPIAPI_UpdateUser_Call) Run(run func(ctx context.Context, id string)) *MockUserAdministrationManagementAPIAPI_UpdateUser_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 *MockUserAdministrationManagementAPIAPI_UpdateUser_Call) Return(apiUpdateUserRequest client.ApiUpdateUserRequest) *MockUserAdministrationManagementAPIAPI_UpdateUser_Call {
	_c.Call.Return(apiUpdateUserRequest)
	return _c
}

func (_c *MockUserAdministrationManagementAPIAPI_UpdateUser_Call) RunAndReturn(run func(ctx context.Context, id string) client.ApiUpdateUserRequest) *MockUserAdministrationManagementAPIAPI_UpdateUser_Call {
	_c.Call.Return(run)
	return _c
}

// UpdateUserExecute provides a mock function for the type MockUserAdministrationManagementAPIAPI
func (_mock *MockUserAdministrationManagementAPIAPI) UpdateUserExecute(r client.ApiUpdateUserRequest) (*http.Response, error) {
	ret := _mock.Called(r)

	if len(ret) == 0 {
		panic("no return value specified for UpdateUserExecute")
	}

	var r0 *http.Response
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(client.ApiUpdateUserRequest) (*http.Response, error)); ok {
		return returnFunc(r)
	}
	if returnFunc, ok := ret.Get(0).(func(client.ApiUpdateUserRequest) *http.Response); ok {
		r0 = returnFunc(r)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*http.Response)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(client.ApiUpdateUserRequest) error); ok {
		r1 = returnFunc(r)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// MockUserAdministrationManagementAPIAPI_UpdateUserExecute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdateUserExecute'
type MockUserAdministrationManagementAPIAPI_UpdateUserExecute_Call struct {
	*mock.Call
}

// UpdateUserExecute is a helper method to define mock.On call
//   - r client.ApiUpdateUserRequest
func (_e *MockUserAdministrationManagementAPIAPI_Expecter) UpdateUserExecute(r interface{}) *MockUserAdministrationManagementAPIAPI_UpdateUserExecute_Call {
	return &MockUserAdministrationManagementAPIAPI_UpdateUserExecute_Call{Call: _e.mock.On("UpdateUserExecute", r)}
}

func (_c *MockUserAdministrationManagementAPIAPI_UpdateUserExecute_Call) Run(run func(r client.ApiUpdateUserRequest)) *MockUserAdministrationManagementAPIAPI_UpdateUserExecute_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 client.ApiUpdateUserRequest
		if args[0] != nil {
			arg0 = args[0].(client.ApiUpdateUserRequest)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *MockUserAdministrationManagementAPIAPI_UpdateUserExecute_Call) Return(response *http.Response, err error) *MockUserAdministrationManagementAPIAPI_UpdateUserExecute_Call {
	_c.Call.Return(response, err)
	return _c
}

func (_c *MockUserAdministrationManagementAPIAPI_UpdateUserExecute_Call) RunAndReturn(run func(r client.ApiUpdateUserRequest) (*http.Response, error)) *MockUserAdministrationManagementAPIAPI_UpdateUserExecute_Call {
	_c.Call.Return(run)
	return _c
}

// UpdateUserSettings provides a mock function for the type MockUserAdministrationManagementAPIAPI
func (_mock *MockUserAdministrationManagementAPIAPI) UpdateUserSettings(ctx context.Context) client.ApiUpdateUserSettingsRequest {
	ret := _mock.Called(ctx)

	if len(ret) == 0 {
		panic("no return value specified for UpdateUserSettings")
	}

	var r0 client.ApiUpdateUserSettingsRequest
	if returnFunc, ok := ret.Get(0).(func(context.Context) client.ApiUpdateUserSettingsRequest); ok {
		r0 = returnFunc(ctx)
	} else {
		r0 = ret.Get(0).(client.ApiUpdateUserSettingsRequest)
	}
	return r0
}

// MockUserAdministrationManagementAPIAPI_UpdateUserSettings_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdateUserSettings'
type MockUserAdministrationManagementAPIAPI_UpdateUserSettings_Call struct {
	*mock.Call
}

// UpdateUserSettings is a helper method to define mock.On call
//   - ctx context.Context
func (_e *MockUserAdministrationManagementAPIAPI_Expecter) UpdateUserSettings(ctx interface{}) *MockUserAdministrationManagementAPIAPI_UpdateUserSettings_Call {
	return &MockUserAdministrationManagementAPIAPI_UpdateUserSettings_Call{Call: _e.mock.On("UpdateUserSettings", ctx)}
}

func (_c *MockUserAdministrationManagementAPIAPI_UpdateUserSettings_Call) Run(run func(ctx context.Context)) *MockUserAdministrationManagementAPIAPI_UpdateUserSettings_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *MockUserAdministrationManagementAPIAPI_UpdateUserSettings_Call) Return(apiUpdateUserSettingsRequest client.ApiUpdateUserSettingsRequest) *MockUserAdministrationManagementAPIAPI_UpdateUserSettings_Call {
	_c.Call.Return(apiUpdateUserSettingsRequest)
	return _c
}

func (_c *MockUserAdministrationManagementAPIAPI_UpdateUserSettings_Call) RunAndReturn(run func(ctx context.Context) client.ApiUpdateUserSettingsRequest) *MockUserAdministrationManagementAPIAPI_UpdateUserSettings_Call {
	_c.Call.Return(run)
	return _c
}

// UpdateUserSettingsExecute provides a mock function for the type MockUserAdministrationManagementAPIAPI
func (_mock *MockUserAdministrationManagementAPIAPI) UpdateUserSettingsExecute(r client.ApiUpdateUserSettingsRequest) (*http.Response, error) {
	ret := _mock.Called(r)

	if len(ret) == 0 {
		panic("no return value specified for UpdateUserSettingsExecute")
	}

	var r0 *http.Response
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(client.ApiUpdateUserSettingsRequest) (*http.Response, error)); ok {
		return returnFunc(r)
	}
	if returnFunc, ok := ret.Get(0).(func(client.ApiUpdateUserSettingsRequest) *http.Response); ok {
		r0 = returnFunc(r)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*http.Response)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(client.ApiUpdateUserSettingsRequest) error); ok {
		r1 = returnFunc(r)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// MockUserAdministrationManagementAPIAPI_UpdateUserSettingsExecute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdateUserSettingsExecute'
type MockUserAdministrationManagementAPIAPI_UpdateUserSettingsExecute_Call struct {
	*mock.Call
}

// UpdateUserSettingsExecute is a helper method to define mock.On call
//   - r client.ApiUpdateUserSettingsRequest
func (_e *MockUserAdministrationManagementAPIAPI_Expecter) UpdateUserSettingsExecute(r interface{}) *MockUserAdministrationManagementAPIAPI_UpdateUserSettingsExecute_Call {
	return &MockUserAdministrationManagementAPIAPI_UpdateUserSettingsExecute_Call{Call: _e.mock.On("UpdateUserSettingsExecute", r)}
}

func (_c *MockUserAdministrationManagementAPIAPI_UpdateUserSettingsExecute_Call) Run(run func(r client.ApiUpdateUserSettingsRequest)) *MockUserAdministrationManagementAPIAPI_UpdateUserSettingsExecute_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 client.ApiUpdateUserSettingsRequest
		if args[0] != nil {
			arg0 = args[0].(client.ApiUpdateUserSettingsRequest)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *MockUserAdministrationManagementAPIAPI_UpdateUserSettingsExecute_Call) Return(response *http.Response, err error) *MockUserAdministrationManagementAPIAPI_UpdateUserSettingsExecute_Call {
	_c.Call.Return(response, err)
	return _c
}

func (_c *MockUserAdministrationManagementAPIAPI_UpdateUserSettingsExecute_Call) RunAndReturn(run func(r client.ApiUpdateUserSettingsRequest) (*http.Response, error)) *MockUserAdministrationManagementAPIAPI_UpdateUserSettingsExecute_Call {
	_c.Call.Return(run)
	return _c
}

// NewMockUserAdministrationV2ManagementAPIAPI creates a new instance of MockUserAdministrationV2ManagementAPIAPI. 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 NewMockUserAdministrationV2ManagementAPIAPI(t interface {
	mock.TestingT
	Cleanup(func())
}) *MockUserAdministrationV2ManagementAPIAPI {
	mock := &MockUserAdministrationV2ManagementAPIAPI{}
	mock.Mock.Test(t)

	t.Cleanup(func() { mock.AssertExpectations(t) })

	return mock
}

// MockUserAdministrationV2ManagementAPIAPI is an autogenerated mock type for the UserAdministrationV2ManagementAPIAPI type
type MockUserAdministrationV2ManagementAPIAPI struct {
	mock.Mock
}

type MockUserAdministrationV2ManagementAPIAPI_Expecter struct {
	mock *mock.Mock
}

func (_m *MockUserAdministrationV2ManagementAPIAPI) EXPECT() *MockUserAdministrationV2ManagementAPIAPI_Expecter {
	return &MockUserAdministrationV2ManagementAPIAPI_Expecter{mock: &_m.Mock}
}

// UseradmV2UpdateOwnUserData provides a mock function for the type MockUserAdministrationV2ManagementAPIAPI
func (_mock *MockUserAdministrationV2ManagementAPIAPI) UseradmV2UpdateOwnUserData(ctx context.Context) client.ApiUseradmV2UpdateOwnUserDataRequest {
	ret := _mock.Called(ctx)

	if len(ret) == 0 {
		panic("no return value specified for UseradmV2UpdateOwnUserData")
	}

	var r0 client.ApiUseradmV2UpdateOwnUserDataRequest
	if returnFunc, ok := ret.Get(0).(func(context.Context) client.ApiUseradmV2UpdateOwnUserDataRequest); ok {
		r0 = returnFunc(ctx)
	} else {
		r0 = ret.Get(0).(client.ApiUseradmV2UpdateOwnUserDataRequest)
	}
	return r0
}

// MockUserAdministrationV2ManagementAPIAPI_UseradmV2UpdateOwnUserData_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UseradmV2UpdateOwnUserData'
type MockUserAdministrationV2ManagementAPIAPI_UseradmV2UpdateOwnUserData_Call struct {
	*mock.Call
}

// UseradmV2UpdateOwnUserData is a helper method to define mock.On call
//   - ctx context.Context
func (_e *MockUserAdministrationV2ManagementAPIAPI_Expecter) UseradmV2UpdateOwnUserData(ctx interface{}) *MockUserAdministrationV2ManagementAPIAPI_UseradmV2UpdateOwnUserData_Call {
	return &MockUserAdministrationV2ManagementAPIAPI_UseradmV2UpdateOwnUserData_Call{Call: _e.mock.On("UseradmV2UpdateOwnUserData", ctx)}
}

func (_c *MockUserAdministrationV2ManagementAPIAPI_UseradmV2UpdateOwnUserData_Call) Run(run func(ctx context.Context)) *MockUserAdministrationV2ManagementAPIAPI_UseradmV2UpdateOwnUserData_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *MockUserAdministrationV2ManagementAPIAPI_UseradmV2UpdateOwnUserData_Call) Return(apiUseradmV2UpdateOwnUserDataRequest client.ApiUseradmV2UpdateOwnUserDataRequest) *MockUserAdministrationV2ManagementAPIAPI_UseradmV2UpdateOwnUserData_Call {
	_c.Call.Return(apiUseradmV2UpdateOwnUserDataRequest)
	return _c
}

func (_c *MockUserAdministrationV2ManagementAPIAPI_UseradmV2UpdateOwnUserData_Call) RunAndReturn(run func(ctx context.Context) client.ApiUseradmV2UpdateOwnUserDataRequest) *MockUserAdministrationV2ManagementAPIAPI_UseradmV2UpdateOwnUserData_Call {
	_c.Call.Return(run)
	return _c
}

// UseradmV2UpdateOwnUserDataExecute provides a mock function for the type MockUserAdministrationV2ManagementAPIAPI
func (_mock *MockUserAdministrationV2ManagementAPIAPI) UseradmV2UpdateOwnUserDataExecute(r client.ApiUseradmV2UpdateOwnUserDataRequest) (*http.Response, error) {
	ret := _mock.Called(r)

	if len(ret) == 0 {
		panic("no return value specified for UseradmV2UpdateOwnUserDataExecute")
	}

	var r0 *http.Response
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(client.ApiUseradmV2UpdateOwnUserDataRequest) (*http.Response, error)); ok {
		return returnFunc(r)
	}
	if returnFunc, ok := ret.Get(0).(func(client.ApiUseradmV2UpdateOwnUserDataRequest) *http.Response); ok {
		r0 = returnFunc(r)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*http.Response)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(client.ApiUseradmV2UpdateOwnUserDataRequest) error); ok {
		r1 = returnFunc(r)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// MockUserAdministrationV2ManagementAPIAPI_UseradmV2UpdateOwnUserDataExecute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UseradmV2UpdateOwnUserDataExecute'
type MockUserAdministrationV2ManagementAPIAPI_UseradmV2UpdateOwnUserDataExecute_Call struct {
	*mock.Call
}

// UseradmV2UpdateOwnUserDataExecute is a helper method to define mock.On call
//   - r client.ApiUseradmV2UpdateOwnUserDataRequest
func (_e *MockUserAdministrationV2ManagementAPIAPI_Expecter) UseradmV2UpdateOwnUserDataExecute(r interface{}) *MockUserAdministrationV2ManagementAPIAPI_UseradmV2UpdateOwnUserDataExecute_Call {
	return &MockUserAdministrationV2ManagementAPIAPI_UseradmV2UpdateOwnUserDataExecute_Call{Call: _e.mock.On("UseradmV2UpdateOwnUserDataExecute", r)}
}

func (_c *MockUserAdministrationV2ManagementAPIAPI_UseradmV2UpdateOwnUserDataExecute_Call) Run(run func(r client.ApiUseradmV2UpdateOwnUserDataRequest)) *MockUserAdministrationV2ManagementAPIAPI_UseradmV2UpdateOwnUserDataExecute_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 client.ApiUseradmV2UpdateOwnUserDataRequest
		if args[0] != nil {
			arg0 = args[0].(client.ApiUseradmV2UpdateOwnUserDataRequest)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *MockUserAdministrationV2ManagementAPIAPI_UseradmV2UpdateOwnUserDataExecute_Call) Return(response *http.Response, err error) *MockUserAdministrationV2ManagementAPIAPI_UseradmV2UpdateOwnUserDataExecute_Call {
	_c.Call.Return(response, err)
	return _c
}

func (_c *MockUserAdministrationV2ManagementAPIAPI_UseradmV2UpdateOwnUserDataExecute_Call) RunAndReturn(run func(r client.ApiUseradmV2UpdateOwnUserDataRequest) (*http.Response, error)) *MockUserAdministrationV2ManagementAPIAPI_UseradmV2UpdateOwnUserDataExecute_Call {
	_c.Call.Return(run)
	return _c
}

// NewMockWorkflowsOtherAPI creates a new instance of MockWorkflowsOtherAPI. 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 NewMockWorkflowsOtherAPI(t interface {
	mock.TestingT
	Cleanup(func())
}) *MockWorkflowsOtherAPI {
	mock := &MockWorkflowsOtherAPI{}
	mock.Mock.Test(t)

	t.Cleanup(func() { mock.AssertExpectations(t) })

	return mock
}

// MockWorkflowsOtherAPI is an autogenerated mock type for the WorkflowsOtherAPI type
type MockWorkflowsOtherAPI struct {
	mock.Mock
}

type MockWorkflowsOtherAPI_Expecter struct {
	mock *mock.Mock
}

func (_m *MockWorkflowsOtherAPI) EXPECT() *MockWorkflowsOtherAPI_Expecter {
	return &MockWorkflowsOtherAPI_Expecter{mock: &_m.Mock}
}

// JobStructure provides a mock function for the type MockWorkflowsOtherAPI
func (_mock *MockWorkflowsOtherAPI) JobStructure(ctx context.Context, id string) client.ApiJobStructureRequest {
	ret := _mock.Called(ctx, id)

	if len(ret) == 0 {
		panic("no return value specified for JobStructure")
	}

	var r0 client.ApiJobStructureRequest
	if returnFunc, ok := ret.Get(0).(func(context.Context, string) client.ApiJobStructureRequest); ok {
		r0 = returnFunc(ctx, id)
	} else {
		r0 = ret.Get(0).(client.ApiJobStructureRequest)
	}
	return r0
}

// MockWorkflowsOtherAPI_JobStructure_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'JobStructure'
type MockWorkflowsOtherAPI_JobStructure_Call struct {
	*mock.Call
}

// JobStructure is a helper method to define mock.On call
//   - ctx context.Context
//   - id string
func (_e *MockWorkflowsOtherAPI_Expecter) JobStructure(ctx interface{}, id interface{}) *MockWorkflowsOtherAPI_JobStructure_Call {
	return &MockWorkflowsOtherAPI_JobStructure_Call{Call: _e.mock.On("JobStructure", ctx, id)}
}

func (_c *MockWorkflowsOtherAPI_JobStructure_Call) Run(run func(ctx context.Context, id string)) *MockWorkflowsOtherAPI_JobStructure_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 *MockWorkflowsOtherAPI_JobStructure_Call) Return(apiJobStructureRequest client.ApiJobStructureRequest) *MockWorkflowsOtherAPI_JobStructure_Call {
	_c.Call.Return(apiJobStructureRequest)
	return _c
}

func (_c *MockWorkflowsOtherAPI_JobStructure_Call) RunAndReturn(run func(ctx context.Context, id string) client.ApiJobStructureRequest) *MockWorkflowsOtherAPI_JobStructure_Call {
	_c.Call.Return(run)
	return _c
}

// JobStructureExecute provides a mock function for the type MockWorkflowsOtherAPI
func (_mock *MockWorkflowsOtherAPI) JobStructureExecute(r client.ApiJobStructureRequest) (*client.JobObject, *http.Response, error) {
	ret := _mock.Called(r)

	if len(ret) == 0 {
		panic("no return value specified for JobStructureExecute")
	}

	var r0 *client.JobObject
	var r1 *http.Response
	var r2 error
	if returnFunc, ok := ret.Get(0).(func(client.ApiJobStructureRequest) (*client.JobObject, *http.Response, error)); ok {
		return returnFunc(r)
	}
	if returnFunc, ok := ret.Get(0).(func(client.ApiJobStructureRequest) *client.JobObject); ok {
		r0 = returnFunc(r)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*client.JobObject)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(client.ApiJobStructureRequest) *http.Response); ok {
		r1 = returnFunc(r)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*http.Response)
		}
	}
	if returnFunc, ok := ret.Get(2).(func(client.ApiJobStructureRequest) error); ok {
		r2 = returnFunc(r)
	} else {
		r2 = ret.Error(2)
	}
	return r0, r1, r2
}

// MockWorkflowsOtherAPI_JobStructureExecute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'JobStructureExecute'
type MockWorkflowsOtherAPI_JobStructureExecute_Call struct {
	*mock.Call
}

// JobStructureExecute is a helper method to define mock.On call
//   - r client.ApiJobStructureRequest
func (_e *MockWorkflowsOtherAPI_Expecter) JobStructureExecute(r interface{}) *MockWorkflowsOtherAPI_JobStructureExecute_Call {
	return &MockWorkflowsOtherAPI_JobStructureExecute_Call{Call: _e.mock.On("JobStructureExecute", r)}
}

func (_c *MockWorkflowsOtherAPI_JobStructureExecute_Call) Run(run func(r client.ApiJobStructureRequest)) *MockWorkflowsOtherAPI_JobStructureExecute_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 client.ApiJobStructureRequest
		if args[0] != nil {
			arg0 = args[0].(client.ApiJobStructureRequest)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *MockWorkflowsOtherAPI_JobStructureExecute_Call) Return(jobObject *client.JobObject, response *http.Response, err error) *MockWorkflowsOtherAPI_JobStructureExecute_Call {
	_c.Call.Return(jobObject, response, err)
	return _c
}

func (_c *MockWorkflowsOtherAPI_JobStructureExecute_Call) RunAndReturn(run func(r client.ApiJobStructureRequest) (*client.JobObject, *http.Response, error)) *MockWorkflowsOtherAPI_JobStructureExecute_Call {
	_c.Call.Return(run)
	return _c
}

// ListWorkflows provides a mock function for the type MockWorkflowsOtherAPI
func (_mock *MockWorkflowsOtherAPI) ListWorkflows(ctx context.Context) client.ApiListWorkflowsRequest {
	ret := _mock.Called(ctx)

	if len(ret) == 0 {
		panic("no return value specified for ListWorkflows")
	}

	var r0 client.ApiListWorkflowsRequest
	if returnFunc, ok := ret.Get(0).(func(context.Context) client.ApiListWorkflowsRequest); ok {
		r0 = returnFunc(ctx)
	} else {
		r0 = ret.Get(0).(client.ApiListWorkflowsRequest)
	}
	return r0
}

// MockWorkflowsOtherAPI_ListWorkflows_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListWorkflows'
type MockWorkflowsOtherAPI_ListWorkflows_Call struct {
	*mock.Call
}

// ListWorkflows is a helper method to define mock.On call
//   - ctx context.Context
func (_e *MockWorkflowsOtherAPI_Expecter) ListWorkflows(ctx interface{}) *MockWorkflowsOtherAPI_ListWorkflows_Call {
	return &MockWorkflowsOtherAPI_ListWorkflows_Call{Call: _e.mock.On("ListWorkflows", ctx)}
}

func (_c *MockWorkflowsOtherAPI_ListWorkflows_Call) Run(run func(ctx context.Context)) *MockWorkflowsOtherAPI_ListWorkflows_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *MockWorkflowsOtherAPI_ListWorkflows_Call) Return(apiListWorkflowsRequest client.ApiListWorkflowsRequest) *MockWorkflowsOtherAPI_ListWorkflows_Call {
	_c.Call.Return(apiListWorkflowsRequest)
	return _c
}

func (_c *MockWorkflowsOtherAPI_ListWorkflows_Call) RunAndReturn(run func(ctx context.Context) client.ApiListWorkflowsRequest) *MockWorkflowsOtherAPI_ListWorkflows_Call {
	_c.Call.Return(run)
	return _c
}

// ListWorkflowsExecute provides a mock function for the type MockWorkflowsOtherAPI
func (_mock *MockWorkflowsOtherAPI) ListWorkflowsExecute(r client.ApiListWorkflowsRequest) ([]client.Workflow, *http.Response, error) {
	ret := _mock.Called(r)

	if len(ret) == 0 {
		panic("no return value specified for ListWorkflowsExecute")
	}

	var r0 []client.Workflow
	var r1 *http.Response
	var r2 error
	if returnFunc, ok := ret.Get(0).(func(client.ApiListWorkflowsRequest) ([]client.Workflow, *http.Response, error)); ok {
		return returnFunc(r)
	}
	if returnFunc, ok := ret.Get(0).(func(client.ApiListWorkflowsRequest) []client.Workflow); ok {
		r0 = returnFunc(r)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]client.Workflow)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(client.ApiListWorkflowsRequest) *http.Response); ok {
		r1 = returnFunc(r)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*http.Response)
		}
	}
	if returnFunc, ok := ret.Get(2).(func(client.ApiListWorkflowsRequest) error); ok {
		r2 = returnFunc(r)
	} else {
		r2 = ret.Error(2)
	}
	return r0, r1, r2
}

// MockWorkflowsOtherAPI_ListWorkflowsExecute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListWorkflowsExecute'
type MockWorkflowsOtherAPI_ListWorkflowsExecute_Call struct {
	*mock.Call
}

// ListWorkflowsExecute is a helper method to define mock.On call
//   - r client.ApiListWorkflowsRequest
func (_e *MockWorkflowsOtherAPI_Expecter) ListWorkflowsExecute(r interface{}) *MockWorkflowsOtherAPI_ListWorkflowsExecute_Call {
	return &MockWorkflowsOtherAPI_ListWorkflowsExecute_Call{Call: _e.mock.On("ListWorkflowsExecute", r)}
}

func (_c *MockWorkflowsOtherAPI_ListWorkflowsExecute_Call) Run(run func(r client.ApiListWorkflowsRequest)) *MockWorkflowsOtherAPI_ListWorkflowsExecute_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 client.ApiListWorkflowsRequest
		if args[0] != nil {
			arg0 = args[0].(client.ApiListWorkflowsRequest)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *MockWorkflowsOtherAPI_ListWorkflowsExecute_Call) Return(workflows []client.Workflow, response *http.Response, err error) *MockWorkflowsOtherAPI_ListWorkflowsExecute_Call {
	_c.Call.Return(workflows, response, err)
	return _c
}

func (_c *MockWorkflowsOtherAPI_ListWorkflowsExecute_Call) RunAndReturn(run func(r client.ApiListWorkflowsRequest) ([]client.Workflow, *http.Response, error)) *MockWorkflowsOtherAPI_ListWorkflowsExecute_Call {
	_c.Call.Return(run)
	return _c
}

// RegisterWorkflow provides a mock function for the type MockWorkflowsOtherAPI
func (_mock *MockWorkflowsOtherAPI) RegisterWorkflow(ctx context.Context) client.ApiRegisterWorkflowRequest {
	ret := _mock.Called(ctx)

	if len(ret) == 0 {
		panic("no return value specified for RegisterWorkflow")
	}

	var r0 client.ApiRegisterWorkflowRequest
	if returnFunc, ok := ret.Get(0).(func(context.Context) client.ApiRegisterWorkflowRequest); ok {
		r0 = returnFunc(ctx)
	} else {
		r0 = ret.Get(0).(client.ApiRegisterWorkflowRequest)
	}
	return r0
}

// MockWorkflowsOtherAPI_RegisterWorkflow_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RegisterWorkflow'
type MockWorkflowsOtherAPI_RegisterWorkflow_Call struct {
	*mock.Call
}

// RegisterWorkflow is a helper method to define mock.On call
//   - ctx context.Context
func (_e *MockWorkflowsOtherAPI_Expecter) RegisterWorkflow(ctx interface{}) *MockWorkflowsOtherAPI_RegisterWorkflow_Call {
	return &MockWorkflowsOtherAPI_RegisterWorkflow_Call{Call: _e.mock.On("RegisterWorkflow", ctx)}
}

func (_c *MockWorkflowsOtherAPI_RegisterWorkflow_Call) Run(run func(ctx context.Context)) *MockWorkflowsOtherAPI_RegisterWorkflow_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *MockWorkflowsOtherAPI_RegisterWorkflow_Call) Return(apiRegisterWorkflowRequest client.ApiRegisterWorkflowRequest) *MockWorkflowsOtherAPI_RegisterWorkflow_Call {
	_c.Call.Return(apiRegisterWorkflowRequest)
	return _c
}

func (_c *MockWorkflowsOtherAPI_RegisterWorkflow_Call) RunAndReturn(run func(ctx context.Context) client.ApiRegisterWorkflowRequest) *MockWorkflowsOtherAPI_RegisterWorkflow_Call {
	_c.Call.Return(run)
	return _c
}

// RegisterWorkflowExecute provides a mock function for the type MockWorkflowsOtherAPI
func (_mock *MockWorkflowsOtherAPI) RegisterWorkflowExecute(r client.ApiRegisterWorkflowRequest) (*http.Response, error) {
	ret := _mock.Called(r)

	if len(ret) == 0 {
		panic("no return value specified for RegisterWorkflowExecute")
	}

	var r0 *http.Response
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(client.ApiRegisterWorkflowRequest) (*http.Response, error)); ok {
		return returnFunc(r)
	}
	if returnFunc, ok := ret.Get(0).(func(client.ApiRegisterWorkflowRequest) *http.Response); ok {
		r0 = returnFunc(r)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*http.Response)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(client.ApiRegisterWorkflowRequest) error); ok {
		r1 = returnFunc(r)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// MockWorkflowsOtherAPI_RegisterWorkflowExecute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RegisterWorkflowExecute'
type MockWorkflowsOtherAPI_RegisterWorkflowExecute_Call struct {
	*mock.Call
}

// RegisterWorkflowExecute is a helper method to define mock.On call
//   - r client.ApiRegisterWorkflowRequest
func (_e *MockWorkflowsOtherAPI_Expecter) RegisterWorkflowExecute(r interface{}) *MockWorkflowsOtherAPI_RegisterWorkflowExecute_Call {
	return &MockWorkflowsOtherAPI_RegisterWorkflowExecute_Call{Call: _e.mock.On("RegisterWorkflowExecute", r)}
}

func (_c *MockWorkflowsOtherAPI_RegisterWorkflowExecute_Call) Run(run func(r client.ApiRegisterWorkflowRequest)) *MockWorkflowsOtherAPI_RegisterWorkflowExecute_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 client.ApiRegisterWorkflowRequest
		if args[0] != nil {
			arg0 = args[0].(client.ApiRegisterWorkflowRequest)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *MockWorkflowsOtherAPI_RegisterWorkflowExecute_Call) Return(response *http.Response, err error) *MockWorkflowsOtherAPI_RegisterWorkflowExecute_Call {
	_c.Call.Return(response, err)
	return _c
}

func (_c *MockWorkflowsOtherAPI_RegisterWorkflowExecute_Call) RunAndReturn(run func(r client.ApiRegisterWorkflowRequest) (*http.Response, error)) *MockWorkflowsOtherAPI_RegisterWorkflowExecute_Call {
	_c.Call.Return(run)
	return _c
}

// StartBatchWorkflows provides a mock function for the type MockWorkflowsOtherAPI
func (_mock *MockWorkflowsOtherAPI) StartBatchWorkflows(ctx context.Context, name string) client.ApiStartBatchWorkflowsRequest {
	ret := _mock.Called(ctx, name)

	if len(ret) == 0 {
		panic("no return value specified for StartBatchWorkflows")
	}

	var r0 client.ApiStartBatchWorkflowsRequest
	if returnFunc, ok := ret.Get(0).(func(context.Context, string) client.ApiStartBatchWorkflowsRequest); ok {
		r0 = returnFunc(ctx, name)
	} else {
		r0 = ret.Get(0).(client.ApiStartBatchWorkflowsRequest)
	}
	return r0
}

// MockWorkflowsOtherAPI_StartBatchWorkflows_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'StartBatchWorkflows'
type MockWorkflowsOtherAPI_StartBatchWorkflows_Call struct {
	*mock.Call
}

// StartBatchWorkflows is a helper method to define mock.On call
//   - ctx context.Context
//   - name string
func (_e *MockWorkflowsOtherAPI_Expecter) StartBatchWorkflows(ctx interface{}, name interface{}) *MockWorkflowsOtherAPI_StartBatchWorkflows_Call {
	return &MockWorkflowsOtherAPI_StartBatchWorkflows_Call{Call: _e.mock.On("StartBatchWorkflows", ctx, name)}
}

func (_c *MockWorkflowsOtherAPI_StartBatchWorkflows_Call) Run(run func(ctx context.Context, name string)) *MockWorkflowsOtherAPI_StartBatchWorkflows_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 *MockWorkflowsOtherAPI_StartBatchWorkflows_Call) Return(apiStartBatchWorkflowsRequest client.ApiStartBatchWorkflowsRequest) *MockWorkflowsOtherAPI_StartBatchWorkflows_Call {
	_c.Call.Return(apiStartBatchWorkflowsRequest)
	return _c
}

func (_c *MockWorkflowsOtherAPI_StartBatchWorkflows_Call) RunAndReturn(run func(ctx context.Context, name string) client.ApiStartBatchWorkflowsRequest) *MockWorkflowsOtherAPI_StartBatchWorkflows_Call {
	_c.Call.Return(run)
	return _c
}

// StartBatchWorkflowsExecute provides a mock function for the type MockWorkflowsOtherAPI
func (_mock *MockWorkflowsOtherAPI) StartBatchWorkflowsExecute(r client.ApiStartBatchWorkflowsRequest) ([]client.StartBatchWorkflows201ResponseInner, *http.Response, error) {
	ret := _mock.Called(r)

	if len(ret) == 0 {
		panic("no return value specified for StartBatchWorkflowsExecute")
	}

	var r0 []client.StartBatchWorkflows201ResponseInner
	var r1 *http.Response
	var r2 error
	if returnFunc, ok := ret.Get(0).(func(client.ApiStartBatchWorkflowsRequest) ([]client.StartBatchWorkflows201ResponseInner, *http.Response, error)); ok {
		return returnFunc(r)
	}
	if returnFunc, ok := ret.Get(0).(func(client.ApiStartBatchWorkflowsRequest) []client.StartBatchWorkflows201ResponseInner); ok {
		r0 = returnFunc(r)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]client.StartBatchWorkflows201ResponseInner)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(client.ApiStartBatchWorkflowsRequest) *http.Response); ok {
		r1 = returnFunc(r)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*http.Response)
		}
	}
	if returnFunc, ok := ret.Get(2).(func(client.ApiStartBatchWorkflowsRequest) error); ok {
		r2 = returnFunc(r)
	} else {
		r2 = ret.Error(2)
	}
	return r0, r1, r2
}

// MockWorkflowsOtherAPI_StartBatchWorkflowsExecute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'StartBatchWorkflowsExecute'
type MockWorkflowsOtherAPI_StartBatchWorkflowsExecute_Call struct {
	*mock.Call
}

// StartBatchWorkflowsExecute is a helper method to define mock.On call
//   - r client.ApiStartBatchWorkflowsRequest
func (_e *MockWorkflowsOtherAPI_Expecter) StartBatchWorkflowsExecute(r interface{}) *MockWorkflowsOtherAPI_StartBatchWorkflowsExecute_Call {
	return &MockWorkflowsOtherAPI_StartBatchWorkflowsExecute_Call{Call: _e.mock.On("StartBatchWorkflowsExecute", r)}
}

func (_c *MockWorkflowsOtherAPI_StartBatchWorkflowsExecute_Call) Run(run func(r client.ApiStartBatchWorkflowsRequest)) *MockWorkflowsOtherAPI_StartBatchWorkflowsExecute_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 client.ApiStartBatchWorkflowsRequest
		if args[0] != nil {
			arg0 = args[0].(client.ApiStartBatchWorkflowsRequest)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *MockWorkflowsOtherAPI_StartBatchWorkflowsExecute_Call) Return(startBatchWorkflows201ResponseInners []client.StartBatchWorkflows201ResponseInner, response *http.Response, err error) *MockWorkflowsOtherAPI_StartBatchWorkflowsExecute_Call {
	_c.Call.Return(startBatchWorkflows201ResponseInners, response, err)
	return _c
}

func (_c *MockWorkflowsOtherAPI_StartBatchWorkflowsExecute_Call) RunAndReturn(run func(r client.ApiStartBatchWorkflowsRequest) ([]client.StartBatchWorkflows201ResponseInner, *http.Response, error)) *MockWorkflowsOtherAPI_StartBatchWorkflowsExecute_Call {
	_c.Call.Return(run)
	return _c
}

// StartWorkflow provides a mock function for the type MockWorkflowsOtherAPI
func (_mock *MockWorkflowsOtherAPI) StartWorkflow(ctx context.Context, name string) client.ApiStartWorkflowRequest {
	ret := _mock.Called(ctx, name)

	if len(ret) == 0 {
		panic("no return value specified for StartWorkflow")
	}

	var r0 client.ApiStartWorkflowRequest
	if returnFunc, ok := ret.Get(0).(func(context.Context, string) client.ApiStartWorkflowRequest); ok {
		r0 = returnFunc(ctx, name)
	} else {
		r0 = ret.Get(0).(client.ApiStartWorkflowRequest)
	}
	return r0
}

// MockWorkflowsOtherAPI_StartWorkflow_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'StartWorkflow'
type MockWorkflowsOtherAPI_StartWorkflow_Call struct {
	*mock.Call
}

// StartWorkflow is a helper method to define mock.On call
//   - ctx context.Context
//   - name string
func (_e *MockWorkflowsOtherAPI_Expecter) StartWorkflow(ctx interface{}, name interface{}) *MockWorkflowsOtherAPI_StartWorkflow_Call {
	return &MockWorkflowsOtherAPI_StartWorkflow_Call{Call: _e.mock.On("StartWorkflow", ctx, name)}
}

func (_c *MockWorkflowsOtherAPI_StartWorkflow_Call) Run(run func(ctx context.Context, name string)) *MockWorkflowsOtherAPI_StartWorkflow_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 *MockWorkflowsOtherAPI_StartWorkflow_Call) Return(apiStartWorkflowRequest client.ApiStartWorkflowRequest) *MockWorkflowsOtherAPI_StartWorkflow_Call {
	_c.Call.Return(apiStartWorkflowRequest)
	return _c
}

func (_c *MockWorkflowsOtherAPI_StartWorkflow_Call) RunAndReturn(run func(ctx context.Context, name string) client.ApiStartWorkflowRequest) *MockWorkflowsOtherAPI_StartWorkflow_Call {
	_c.Call.Return(run)
	return _c
}

// StartWorkflowExecute provides a mock function for the type MockWorkflowsOtherAPI
func (_mock *MockWorkflowsOtherAPI) StartWorkflowExecute(r client.ApiStartWorkflowRequest) (*client.StartWorkflow201Response, *http.Response, error) {
	ret := _mock.Called(r)

	if len(ret) == 0 {
		panic("no return value specified for StartWorkflowExecute")
	}

	var r0 *client.StartWorkflow201Response
	var r1 *http.Response
	var r2 error
	if returnFunc, ok := ret.Get(0).(func(client.ApiStartWorkflowRequest) (*client.StartWorkflow201Response, *http.Response, error)); ok {
		return returnFunc(r)
	}
	if returnFunc, ok := ret.Get(0).(func(client.ApiStartWorkflowRequest) *client.StartWorkflow201Response); ok {
		r0 = returnFunc(r)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*client.StartWorkflow201Response)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(client.ApiStartWorkflowRequest) *http.Response); ok {
		r1 = returnFunc(r)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*http.Response)
		}
	}
	if returnFunc, ok := ret.Get(2).(func(client.ApiStartWorkflowRequest) error); ok {
		r2 = returnFunc(r)
	} else {
		r2 = ret.Error(2)
	}
	return r0, r1, r2
}

// MockWorkflowsOtherAPI_StartWorkflowExecute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'StartWorkflowExecute'
type MockWorkflowsOtherAPI_StartWorkflowExecute_Call struct {
	*mock.Call
}

// StartWorkflowExecute is a helper method to define mock.On call
//   - r client.ApiStartWorkflowRequest
func (_e *MockWorkflowsOtherAPI_Expecter) StartWorkflowExecute(r interface{}) *MockWorkflowsOtherAPI_StartWorkflowExecute_Call {
	return &MockWorkflowsOtherAPI_StartWorkflowExecute_Call{Call: _e.mock.On("StartWorkflowExecute", r)}
}

func (_c *MockWorkflowsOtherAPI_StartWorkflowExecute_Call) Run(run func(r client.ApiStartWorkflowRequest)) *MockWorkflowsOtherAPI_StartWorkflowExecute_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 client.ApiStartWorkflowRequest
		if args[0] != nil {
			arg0 = args[0].(client.ApiStartWorkflowRequest)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *MockWorkflowsOtherAPI_StartWorkflowExecute_Call) Return(startWorkflow201Response *client.StartWorkflow201Response, response *http.Response, err error) *MockWorkflowsOtherAPI_StartWorkflowExecute_Call {
	_c.Call.Return(startWorkflow201Response, response, err)
	return _c
}

func (_c *MockWorkflowsOtherAPI_StartWorkflowExecute_Call) RunAndReturn(run func(r client.ApiStartWorkflowRequest) (*client.StartWorkflow201Response, *http.Response, error)) *MockWorkflowsOtherAPI_StartWorkflowExecute_Call {
	_c.Call.Return(run)
	return _c
}

// WorkflowsCheckHealth provides a mock function for the type MockWorkflowsOtherAPI
func (_mock *MockWorkflowsOtherAPI) WorkflowsCheckHealth(ctx context.Context) client.ApiWorkflowsCheckHealthRequest {
	ret := _mock.Called(ctx)

	if len(ret) == 0 {
		panic("no return value specified for WorkflowsCheckHealth")
	}

	var r0 client.ApiWorkflowsCheckHealthRequest
	if returnFunc, ok := ret.Get(0).(func(context.Context) client.ApiWorkflowsCheckHealthRequest); ok {
		r0 = returnFunc(ctx)
	} else {
		r0 = ret.Get(0).(client.ApiWorkflowsCheckHealthRequest)
	}
	return r0
}

// MockWorkflowsOtherAPI_WorkflowsCheckHealth_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'WorkflowsCheckHealth'
type MockWorkflowsOtherAPI_WorkflowsCheckHealth_Call struct {
	*mock.Call
}

// WorkflowsCheckHealth is a helper method to define mock.On call
//   - ctx context.Context
func (_e *MockWorkflowsOtherAPI_Expecter) WorkflowsCheckHealth(ctx interface{}) *MockWorkflowsOtherAPI_WorkflowsCheckHealth_Call {
	return &MockWorkflowsOtherAPI_WorkflowsCheckHealth_Call{Call: _e.mock.On("WorkflowsCheckHealth", ctx)}
}

func (_c *MockWorkflowsOtherAPI_WorkflowsCheckHealth_Call) Run(run func(ctx context.Context)) *MockWorkflowsOtherAPI_WorkflowsCheckHealth_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *MockWorkflowsOtherAPI_WorkflowsCheckHealth_Call) Return(apiWorkflowsCheckHealthRequest client.ApiWorkflowsCheckHealthRequest) *MockWorkflowsOtherAPI_WorkflowsCheckHealth_Call {
	_c.Call.Return(apiWorkflowsCheckHealthRequest)
	return _c
}

func (_c *MockWorkflowsOtherAPI_WorkflowsCheckHealth_Call) RunAndReturn(run func(ctx context.Context) client.ApiWorkflowsCheckHealthRequest) *MockWorkflowsOtherAPI_WorkflowsCheckHealth_Call {
	_c.Call.Return(run)
	return _c
}

// WorkflowsCheckHealthExecute provides a mock function for the type MockWorkflowsOtherAPI
func (_mock *MockWorkflowsOtherAPI) WorkflowsCheckHealthExecute(r client.ApiWorkflowsCheckHealthRequest) (*http.Response, error) {
	ret := _mock.Called(r)

	if len(ret) == 0 {
		panic("no return value specified for WorkflowsCheckHealthExecute")
	}

	var r0 *http.Response
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(client.ApiWorkflowsCheckHealthRequest) (*http.Response, error)); ok {
		return returnFunc(r)
	}
	if returnFunc, ok := ret.Get(0).(func(client.ApiWorkflowsCheckHealthRequest) *http.Response); ok {
		r0 = returnFunc(r)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*http.Response)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(client.ApiWorkflowsCheckHealthRequest) error); ok {
		r1 = returnFunc(r)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// MockWorkflowsOtherAPI_WorkflowsCheckHealthExecute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'WorkflowsCheckHealthExecute'
type MockWorkflowsOtherAPI_WorkflowsCheckHealthExecute_Call struct {
	*mock.Call
}

// WorkflowsCheckHealthExecute is a helper method to define mock.On call
//   - r client.ApiWorkflowsCheckHealthRequest
func (_e *MockWorkflowsOtherAPI_Expecter) WorkflowsCheckHealthExecute(r interface{}) *MockWorkflowsOtherAPI_WorkflowsCheckHealthExecute_Call {
	return &MockWorkflowsOtherAPI_WorkflowsCheckHealthExecute_Call{Call: _e.mock.On("WorkflowsCheckHealthExecute", r)}
}

func (_c *MockWorkflowsOtherAPI_WorkflowsCheckHealthExecute_Call) Run(run func(r client.ApiWorkflowsCheckHealthRequest)) *MockWorkflowsOtherAPI_WorkflowsCheckHealthExecute_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 client.ApiWorkflowsCheckHealthRequest
		if args[0] != nil {
			arg0 = args[0].(client.ApiWorkflowsCheckHealthRequest)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *MockWorkflowsOtherAPI_WorkflowsCheckHealthExecute_Call) Return(response *http.Response, err error) *MockWorkflowsOtherAPI_WorkflowsCheckHealthExecute_Call {
	_c.Call.Return(response, err)
	return _c
}

func (_c *MockWorkflowsOtherAPI_WorkflowsCheckHealthExecute_Call) RunAndReturn(run func(r client.ApiWorkflowsCheckHealthRequest) (*http.Response, error)) *MockWorkflowsOtherAPI_WorkflowsCheckHealthExecute_Call {
	_c.Call.Return(run)
	return _c
}

// WorkflowsCheckLiveliness provides a mock function for the type MockWorkflowsOtherAPI
func (_mock *MockWorkflowsOtherAPI) WorkflowsCheckLiveliness(ctx context.Context) client.ApiWorkflowsCheckLivelinessRequest {
	ret := _mock.Called(ctx)

	if len(ret) == 0 {
		panic("no return value specified for WorkflowsCheckLiveliness")
	}

	var r0 client.ApiWorkflowsCheckLivelinessRequest
	if returnFunc, ok := ret.Get(0).(func(context.Context) client.ApiWorkflowsCheckLivelinessRequest); ok {
		r0 = returnFunc(ctx)
	} else {
		r0 = ret.Get(0).(client.ApiWorkflowsCheckLivelinessRequest)
	}
	return r0
}

// MockWorkflowsOtherAPI_WorkflowsCheckLiveliness_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'WorkflowsCheckLiveliness'
type MockWorkflowsOtherAPI_WorkflowsCheckLiveliness_Call struct {
	*mock.Call
}

// WorkflowsCheckLiveliness is a helper method to define mock.On call
//   - ctx context.Context
func (_e *MockWorkflowsOtherAPI_Expecter) WorkflowsCheckLiveliness(ctx interface{}) *MockWorkflowsOtherAPI_WorkflowsCheckLiveliness_Call {
	return &MockWorkflowsOtherAPI_WorkflowsCheckLiveliness_Call{Call: _e.mock.On("WorkflowsCheckLiveliness", ctx)}
}

func (_c *MockWorkflowsOtherAPI_WorkflowsCheckLiveliness_Call) Run(run func(ctx context.Context)) *MockWorkflowsOtherAPI_WorkflowsCheckLiveliness_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *MockWorkflowsOtherAPI_WorkflowsCheckLiveliness_Call) Return(apiWorkflowsCheckLivelinessRequest client.ApiWorkflowsCheckLivelinessRequest) *MockWorkflowsOtherAPI_WorkflowsCheckLiveliness_Call {
	_c.Call.Return(apiWorkflowsCheckLivelinessRequest)
	return _c
}

func (_c *MockWorkflowsOtherAPI_WorkflowsCheckLiveliness_Call) RunAndReturn(run func(ctx context.Context) client.ApiWorkflowsCheckLivelinessRequest) *MockWorkflowsOtherAPI_WorkflowsCheckLiveliness_Call {
	_c.Call.Return(run)
	return _c
}

// WorkflowsCheckLivelinessExecute provides a mock function for the type MockWorkflowsOtherAPI
func (_mock *MockWorkflowsOtherAPI) WorkflowsCheckLivelinessExecute(r client.ApiWorkflowsCheckLivelinessRequest) (*client.WorkflowsCheckLiveliness200Response, *http.Response, error) {
	ret := _mock.Called(r)

	if len(ret) == 0 {
		panic("no return value specified for WorkflowsCheckLivelinessExecute")
	}

	var r0 *client.WorkflowsCheckLiveliness200Response
	var r1 *http.Response
	var r2 error
	if returnFunc, ok := ret.Get(0).(func(client.ApiWorkflowsCheckLivelinessRequest) (*client.WorkflowsCheckLiveliness200Response, *http.Response, error)); ok {
		return returnFunc(r)
	}
	if returnFunc, ok := ret.Get(0).(func(client.ApiWorkflowsCheckLivelinessRequest) *client.WorkflowsCheckLiveliness200Response); ok {
		r0 = returnFunc(r)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*client.WorkflowsCheckLiveliness200Response)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(client.ApiWorkflowsCheckLivelinessRequest) *http.Response); ok {
		r1 = returnFunc(r)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*http.Response)
		}
	}
	if returnFunc, ok := ret.Get(2).(func(client.ApiWorkflowsCheckLivelinessRequest) error); ok {
		r2 = returnFunc(r)
	} else {
		r2 = ret.Error(2)
	}
	return r0, r1, r2
}

// MockWorkflowsOtherAPI_WorkflowsCheckLivelinessExecute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'WorkflowsCheckLivelinessExecute'
type MockWorkflowsOtherAPI_WorkflowsCheckLivelinessExecute_Call struct {
	*mock.Call
}

// WorkflowsCheckLivelinessExecute is a helper method to define mock.On call
//   - r client.ApiWorkflowsCheckLivelinessRequest
func (_e *MockWorkflowsOtherAPI_Expecter) WorkflowsCheckLivelinessExecute(r interface{}) *MockWorkflowsOtherAPI_WorkflowsCheckLivelinessExecute_Call {
	return &MockWorkflowsOtherAPI_WorkflowsCheckLivelinessExecute_Call{Call: _e.mock.On("WorkflowsCheckLivelinessExecute", r)}
}

func (_c *MockWorkflowsOtherAPI_WorkflowsCheckLivelinessExecute_Call) Run(run func(r client.ApiWorkflowsCheckLivelinessRequest)) *MockWorkflowsOtherAPI_WorkflowsCheckLivelinessExecute_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 client.ApiWorkflowsCheckLivelinessRequest
		if args[0] != nil {
			arg0 = args[0].(client.ApiWorkflowsCheckLivelinessRequest)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *MockWorkflowsOtherAPI_WorkflowsCheckLivelinessExecute_Call) Return(workflowsCheckLiveliness200Response *client.WorkflowsCheckLiveliness200Response, response *http.Response, err error) *MockWorkflowsOtherAPI_WorkflowsCheckLivelinessExecute_Call {
	_c.Call.Return(workflowsCheckLiveliness200Response, response, err)
	return _c
}

func (_c *MockWorkflowsOtherAPI_WorkflowsCheckLivelinessExecute_Call) RunAndReturn(run func(r client.ApiWorkflowsCheckLivelinessRequest) (*client.WorkflowsCheckLiveliness200Response, *http.Response, error)) *MockWorkflowsOtherAPI_WorkflowsCheckLivelinessExecute_Call {
	_c.Call.Return(run)
	return _c
}
