// Code generated by mockery v1.0.0. DO NOT EDIT.

package mocks

import client "opendev.org/airship/go-redfish/client"
import context "context"
import http "net/http"
import mock "github.com/stretchr/testify/mock"

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

// CreateVirtualDisk provides a mock function with given fields: _a0, _a1, _a2
func (_m *RedfishAPI) CreateVirtualDisk(_a0 context.Context, _a1 string, _a2 string) client.ApiCreateVirtualDiskRequest {
	ret := _m.Called(_a0, _a1, _a2)

	var r0 client.ApiCreateVirtualDiskRequest
	if rf, ok := ret.Get(0).(func(context.Context, string, string) client.ApiCreateVirtualDiskRequest); ok {
		r0 = rf(_a0, _a1, _a2)
	} else {
		r0 = ret.Get(0).(client.ApiCreateVirtualDiskRequest)
	}

	return r0
}

// CreateVirtualDiskExecute provides a mock function with given fields: _a0
func (_m *RedfishAPI) CreateVirtualDiskExecute(_a0 client.ApiCreateVirtualDiskRequest) (client.RedfishError, *http.Response, error) {
	ret := _m.Called(_a0)

	var r0 client.RedfishError
	if rf, ok := ret.Get(0).(func(client.ApiCreateVirtualDiskRequest) client.RedfishError); ok {
		r0 = rf(_a0)
	} else {
		r0 = ret.Get(0).(client.RedfishError)
	}

	var r1 *http.Response
	if rf, ok := ret.Get(1).(func(client.ApiCreateVirtualDiskRequest) *http.Response); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*http.Response)
		}
	}

	var r2 error
	if rf, ok := ret.Get(2).(func(client.ApiCreateVirtualDiskRequest) error); ok {
		r2 = rf(_a0)
	} else {
		r2 = ret.Error(2)
	}

	return r0, r1, r2
}

// DeleteVirtualdisk provides a mock function with given fields: _a0, _a1, _a2
func (_m *RedfishAPI) DeleteVirtualdisk(_a0 context.Context, _a1 string, _a2 string) client.ApiDeleteVirtualdiskRequest {
	ret := _m.Called(_a0, _a1, _a2)

	var r0 client.ApiDeleteVirtualdiskRequest
	if rf, ok := ret.Get(0).(func(context.Context, string, string) client.ApiDeleteVirtualdiskRequest); ok {
		r0 = rf(_a0, _a1, _a2)
	} else {
		r0 = ret.Get(0).(client.ApiDeleteVirtualdiskRequest)
	}

	return r0
}

// DeleteVirtualdiskExecute provides a mock function with given fields: _a0
func (_m *RedfishAPI) DeleteVirtualdiskExecute(_a0 client.ApiDeleteVirtualdiskRequest) (*http.Response, error) {
	ret := _m.Called(_a0)

	var r0 *http.Response
	if rf, ok := ret.Get(0).(func(client.ApiDeleteVirtualdiskRequest) *http.Response); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*http.Response)
		}
	}

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

	return r0, r1
}

// EjectVirtualMedia provides a mock function with given fields: _a0, _a1, _a2
func (_m *RedfishAPI) EjectVirtualMedia(_a0 context.Context, _a1 string, _a2 string) client.ApiEjectVirtualMediaRequest {
	ret := _m.Called(_a0, _a1, _a2)

	var r0 client.ApiEjectVirtualMediaRequest
	if rf, ok := ret.Get(0).(func(context.Context, string, string) client.ApiEjectVirtualMediaRequest); ok {
		r0 = rf(_a0, _a1, _a2)
	} else {
		r0 = ret.Get(0).(client.ApiEjectVirtualMediaRequest)
	}

	return r0
}

// EjectVirtualMediaExecute provides a mock function with given fields: _a0
func (_m *RedfishAPI) EjectVirtualMediaExecute(_a0 client.ApiEjectVirtualMediaRequest) (client.RedfishError, *http.Response, error) {
	ret := _m.Called(_a0)

	var r0 client.RedfishError
	if rf, ok := ret.Get(0).(func(client.ApiEjectVirtualMediaRequest) client.RedfishError); ok {
		r0 = rf(_a0)
	} else {
		r0 = ret.Get(0).(client.RedfishError)
	}

	var r1 *http.Response
	if rf, ok := ret.Get(1).(func(client.ApiEjectVirtualMediaRequest) *http.Response); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*http.Response)
		}
	}

	var r2 error
	if rf, ok := ret.Get(2).(func(client.ApiEjectVirtualMediaRequest) error); ok {
		r2 = rf(_a0)
	} else {
		r2 = ret.Error(2)
	}

	return r0, r1, r2
}

// FirmwareInventory provides a mock function with given fields: _a0
func (_m *RedfishAPI) FirmwareInventory(_a0 context.Context) client.ApiFirmwareInventoryRequest {
	ret := _m.Called(_a0)

	var r0 client.ApiFirmwareInventoryRequest
	if rf, ok := ret.Get(0).(func(context.Context) client.ApiFirmwareInventoryRequest); ok {
		r0 = rf(_a0)
	} else {
		r0 = ret.Get(0).(client.ApiFirmwareInventoryRequest)
	}

	return r0
}

// FirmwareInventoryDownloadImage provides a mock function with given fields: _a0
func (_m *RedfishAPI) FirmwareInventoryDownloadImage(_a0 context.Context) client.ApiFirmwareInventoryDownloadImageRequest {
	ret := _m.Called(_a0)

	var r0 client.ApiFirmwareInventoryDownloadImageRequest
	if rf, ok := ret.Get(0).(func(context.Context) client.ApiFirmwareInventoryDownloadImageRequest); ok {
		r0 = rf(_a0)
	} else {
		r0 = ret.Get(0).(client.ApiFirmwareInventoryDownloadImageRequest)
	}

	return r0
}

// FirmwareInventoryDownloadImageExecute provides a mock function with given fields: _a0
func (_m *RedfishAPI) FirmwareInventoryDownloadImageExecute(_a0 client.ApiFirmwareInventoryDownloadImageRequest) (client.RedfishError, *http.Response, error) {
	ret := _m.Called(_a0)

	var r0 client.RedfishError
	if rf, ok := ret.Get(0).(func(client.ApiFirmwareInventoryDownloadImageRequest) client.RedfishError); ok {
		r0 = rf(_a0)
	} else {
		r0 = ret.Get(0).(client.RedfishError)
	}

	var r1 *http.Response
	if rf, ok := ret.Get(1).(func(client.ApiFirmwareInventoryDownloadImageRequest) *http.Response); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*http.Response)
		}
	}

	var r2 error
	if rf, ok := ret.Get(2).(func(client.ApiFirmwareInventoryDownloadImageRequest) error); ok {
		r2 = rf(_a0)
	} else {
		r2 = ret.Error(2)
	}

	return r0, r1, r2
}

// FirmwareInventoryExecute provides a mock function with given fields: _a0
func (_m *RedfishAPI) FirmwareInventoryExecute(_a0 client.ApiFirmwareInventoryRequest) (client.Collection, *http.Response, error) {
	ret := _m.Called(_a0)

	var r0 client.Collection
	if rf, ok := ret.Get(0).(func(client.ApiFirmwareInventoryRequest) client.Collection); ok {
		r0 = rf(_a0)
	} else {
		r0 = ret.Get(0).(client.Collection)
	}

	var r1 *http.Response
	if rf, ok := ret.Get(1).(func(client.ApiFirmwareInventoryRequest) *http.Response); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*http.Response)
		}
	}

	var r2 error
	if rf, ok := ret.Get(2).(func(client.ApiFirmwareInventoryRequest) error); ok {
		r2 = rf(_a0)
	} else {
		r2 = ret.Error(2)
	}

	return r0, r1, r2
}

// GetManager provides a mock function with given fields: _a0, _a1
func (_m *RedfishAPI) GetManager(_a0 context.Context, _a1 string) client.ApiGetManagerRequest {
	ret := _m.Called(_a0, _a1)

	var r0 client.ApiGetManagerRequest
	if rf, ok := ret.Get(0).(func(context.Context, string) client.ApiGetManagerRequest); ok {
		r0 = rf(_a0, _a1)
	} else {
		r0 = ret.Get(0).(client.ApiGetManagerRequest)
	}

	return r0
}

// GetManagerExecute provides a mock function with given fields: _a0
func (_m *RedfishAPI) GetManagerExecute(_a0 client.ApiGetManagerRequest) (client.Manager, *http.Response, error) {
	ret := _m.Called(_a0)

	var r0 client.Manager
	if rf, ok := ret.Get(0).(func(client.ApiGetManagerRequest) client.Manager); ok {
		r0 = rf(_a0)
	} else {
		r0 = ret.Get(0).(client.Manager)
	}

	var r1 *http.Response
	if rf, ok := ret.Get(1).(func(client.ApiGetManagerRequest) *http.Response); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*http.Response)
		}
	}

	var r2 error
	if rf, ok := ret.Get(2).(func(client.ApiGetManagerRequest) error); ok {
		r2 = rf(_a0)
	} else {
		r2 = ret.Error(2)
	}

	return r0, r1, r2
}

// GetManagerVirtualMedia provides a mock function with given fields: _a0, _a1, _a2
func (_m *RedfishAPI) GetManagerVirtualMedia(_a0 context.Context, _a1 string, _a2 string) client.ApiGetManagerVirtualMediaRequest {
	ret := _m.Called(_a0, _a1, _a2)

	var r0 client.ApiGetManagerVirtualMediaRequest
	if rf, ok := ret.Get(0).(func(context.Context, string, string) client.ApiGetManagerVirtualMediaRequest); ok {
		r0 = rf(_a0, _a1, _a2)
	} else {
		r0 = ret.Get(0).(client.ApiGetManagerVirtualMediaRequest)
	}

	return r0
}

// GetManagerVirtualMediaExecute provides a mock function with given fields: _a0
func (_m *RedfishAPI) GetManagerVirtualMediaExecute(_a0 client.ApiGetManagerVirtualMediaRequest) (client.VirtualMedia, *http.Response, error) {
	ret := _m.Called(_a0)

	var r0 client.VirtualMedia
	if rf, ok := ret.Get(0).(func(client.ApiGetManagerVirtualMediaRequest) client.VirtualMedia); ok {
		r0 = rf(_a0)
	} else {
		r0 = ret.Get(0).(client.VirtualMedia)
	}

	var r1 *http.Response
	if rf, ok := ret.Get(1).(func(client.ApiGetManagerVirtualMediaRequest) *http.Response); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*http.Response)
		}
	}

	var r2 error
	if rf, ok := ret.Get(2).(func(client.ApiGetManagerVirtualMediaRequest) error); ok {
		r2 = rf(_a0)
	} else {
		r2 = ret.Error(2)
	}

	return r0, r1, r2
}

// GetRoot provides a mock function with given fields: _a0
func (_m *RedfishAPI) GetRoot(_a0 context.Context) client.ApiGetRootRequest {
	ret := _m.Called(_a0)

	var r0 client.ApiGetRootRequest
	if rf, ok := ret.Get(0).(func(context.Context) client.ApiGetRootRequest); ok {
		r0 = rf(_a0)
	} else {
		r0 = ret.Get(0).(client.ApiGetRootRequest)
	}

	return r0
}

// GetRootExecute provides a mock function with given fields: _a0
func (_m *RedfishAPI) GetRootExecute(_a0 client.ApiGetRootRequest) (client.Root, *http.Response, error) {
	ret := _m.Called(_a0)

	var r0 client.Root
	if rf, ok := ret.Get(0).(func(client.ApiGetRootRequest) client.Root); ok {
		r0 = rf(_a0)
	} else {
		r0 = ret.Get(0).(client.Root)
	}

	var r1 *http.Response
	if rf, ok := ret.Get(1).(func(client.ApiGetRootRequest) *http.Response); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*http.Response)
		}
	}

	var r2 error
	if rf, ok := ret.Get(2).(func(client.ApiGetRootRequest) error); ok {
		r2 = rf(_a0)
	} else {
		r2 = ret.Error(2)
	}

	return r0, r1, r2
}

// GetSoftwareInventory provides a mock function with given fields: _a0, _a1
func (_m *RedfishAPI) GetSoftwareInventory(_a0 context.Context, _a1 string) client.ApiGetSoftwareInventoryRequest {
	ret := _m.Called(_a0, _a1)

	var r0 client.ApiGetSoftwareInventoryRequest
	if rf, ok := ret.Get(0).(func(context.Context, string) client.ApiGetSoftwareInventoryRequest); ok {
		r0 = rf(_a0, _a1)
	} else {
		r0 = ret.Get(0).(client.ApiGetSoftwareInventoryRequest)
	}

	return r0
}

// GetSoftwareInventoryExecute provides a mock function with given fields: _a0
func (_m *RedfishAPI) GetSoftwareInventoryExecute(_a0 client.ApiGetSoftwareInventoryRequest) (client.SoftwareInventory, *http.Response, error) {
	ret := _m.Called(_a0)

	var r0 client.SoftwareInventory
	if rf, ok := ret.Get(0).(func(client.ApiGetSoftwareInventoryRequest) client.SoftwareInventory); ok {
		r0 = rf(_a0)
	} else {
		r0 = ret.Get(0).(client.SoftwareInventory)
	}

	var r1 *http.Response
	if rf, ok := ret.Get(1).(func(client.ApiGetSoftwareInventoryRequest) *http.Response); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*http.Response)
		}
	}

	var r2 error
	if rf, ok := ret.Get(2).(func(client.ApiGetSoftwareInventoryRequest) error); ok {
		r2 = rf(_a0)
	} else {
		r2 = ret.Error(2)
	}

	return r0, r1, r2
}

// GetSystem provides a mock function with given fields: _a0, _a1
func (_m *RedfishAPI) GetSystem(_a0 context.Context, _a1 string) client.ApiGetSystemRequest {
	ret := _m.Called(_a0, _a1)

	var r0 client.ApiGetSystemRequest
	if rf, ok := ret.Get(0).(func(context.Context, string) client.ApiGetSystemRequest); ok {
		r0 = rf(_a0, _a1)
	} else {
		r0 = ret.Get(0).(client.ApiGetSystemRequest)
	}

	return r0
}

// GetSystemExecute provides a mock function with given fields: _a0
func (_m *RedfishAPI) GetSystemExecute(_a0 client.ApiGetSystemRequest) (client.ComputerSystem, *http.Response, error) {
	ret := _m.Called(_a0)

	var r0 client.ComputerSystem
	if rf, ok := ret.Get(0).(func(client.ApiGetSystemRequest) client.ComputerSystem); ok {
		r0 = rf(_a0)
	} else {
		r0 = ret.Get(0).(client.ComputerSystem)
	}

	var r1 *http.Response
	if rf, ok := ret.Get(1).(func(client.ApiGetSystemRequest) *http.Response); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*http.Response)
		}
	}

	var r2 error
	if rf, ok := ret.Get(2).(func(client.ApiGetSystemRequest) error); ok {
		r2 = rf(_a0)
	} else {
		r2 = ret.Error(2)
	}

	return r0, r1, r2
}

// GetTask provides a mock function with given fields: _a0, _a1
func (_m *RedfishAPI) GetTask(_a0 context.Context, _a1 string) client.ApiGetTaskRequest {
	ret := _m.Called(_a0, _a1)

	var r0 client.ApiGetTaskRequest
	if rf, ok := ret.Get(0).(func(context.Context, string) client.ApiGetTaskRequest); ok {
		r0 = rf(_a0, _a1)
	} else {
		r0 = ret.Get(0).(client.ApiGetTaskRequest)
	}

	return r0
}

// GetTaskExecute provides a mock function with given fields: _a0
func (_m *RedfishAPI) GetTaskExecute(_a0 client.ApiGetTaskRequest) (client.Task, *http.Response, error) {
	ret := _m.Called(_a0)

	var r0 client.Task
	if rf, ok := ret.Get(0).(func(client.ApiGetTaskRequest) client.Task); ok {
		r0 = rf(_a0)
	} else {
		r0 = ret.Get(0).(client.Task)
	}

	var r1 *http.Response
	if rf, ok := ret.Get(1).(func(client.ApiGetTaskRequest) *http.Response); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*http.Response)
		}
	}

	var r2 error
	if rf, ok := ret.Get(2).(func(client.ApiGetTaskRequest) error); ok {
		r2 = rf(_a0)
	} else {
		r2 = ret.Error(2)
	}

	return r0, r1, r2
}

// GetTaskList provides a mock function with given fields: _a0
func (_m *RedfishAPI) GetTaskList(_a0 context.Context) client.ApiGetTaskListRequest {
	ret := _m.Called(_a0)

	var r0 client.ApiGetTaskListRequest
	if rf, ok := ret.Get(0).(func(context.Context) client.ApiGetTaskListRequest); ok {
		r0 = rf(_a0)
	} else {
		r0 = ret.Get(0).(client.ApiGetTaskListRequest)
	}

	return r0
}

// GetTaskListExecute provides a mock function with given fields: _a0
func (_m *RedfishAPI) GetTaskListExecute(_a0 client.ApiGetTaskListRequest) (client.Collection, *http.Response, error) {
	ret := _m.Called(_a0)

	var r0 client.Collection
	if rf, ok := ret.Get(0).(func(client.ApiGetTaskListRequest) client.Collection); ok {
		r0 = rf(_a0)
	} else {
		r0 = ret.Get(0).(client.Collection)
	}

	var r1 *http.Response
	if rf, ok := ret.Get(1).(func(client.ApiGetTaskListRequest) *http.Response); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*http.Response)
		}
	}

	var r2 error
	if rf, ok := ret.Get(2).(func(client.ApiGetTaskListRequest) error); ok {
		r2 = rf(_a0)
	} else {
		r2 = ret.Error(2)
	}

	return r0, r1, r2
}

// GetVolumes provides a mock function with given fields: _a0, _a1, _a2
func (_m *RedfishAPI) GetVolumes(_a0 context.Context, _a1 string, _a2 string) client.ApiGetVolumesRequest {
	ret := _m.Called(_a0, _a1, _a2)

	var r0 client.ApiGetVolumesRequest
	if rf, ok := ret.Get(0).(func(context.Context, string, string) client.ApiGetVolumesRequest); ok {
		r0 = rf(_a0, _a1, _a2)
	} else {
		r0 = ret.Get(0).(client.ApiGetVolumesRequest)
	}

	return r0
}

// GetVolumesExecute provides a mock function with given fields: _a0
func (_m *RedfishAPI) GetVolumesExecute(_a0 client.ApiGetVolumesRequest) (client.Collection, *http.Response, error) {
	ret := _m.Called(_a0)

	var r0 client.Collection
	if rf, ok := ret.Get(0).(func(client.ApiGetVolumesRequest) client.Collection); ok {
		r0 = rf(_a0)
	} else {
		r0 = ret.Get(0).(client.Collection)
	}

	var r1 *http.Response
	if rf, ok := ret.Get(1).(func(client.ApiGetVolumesRequest) *http.Response); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*http.Response)
		}
	}

	var r2 error
	if rf, ok := ret.Get(2).(func(client.ApiGetVolumesRequest) error); ok {
		r2 = rf(_a0)
	} else {
		r2 = ret.Error(2)
	}

	return r0, r1, r2
}

// InsertVirtualMedia provides a mock function with given fields: _a0, _a1, _a2
func (_m *RedfishAPI) InsertVirtualMedia(_a0 context.Context, _a1 string, _a2 string) client.ApiInsertVirtualMediaRequest {
	ret := _m.Called(_a0, _a1, _a2)

	var r0 client.ApiInsertVirtualMediaRequest
	if rf, ok := ret.Get(0).(func(context.Context, string, string) client.ApiInsertVirtualMediaRequest); ok {
		r0 = rf(_a0, _a1, _a2)
	} else {
		r0 = ret.Get(0).(client.ApiInsertVirtualMediaRequest)
	}

	return r0
}

// InsertVirtualMediaExecute provides a mock function with given fields: _a0
func (_m *RedfishAPI) InsertVirtualMediaExecute(_a0 client.ApiInsertVirtualMediaRequest) (client.RedfishError, *http.Response, error) {
	ret := _m.Called(_a0)

	var r0 client.RedfishError
	if rf, ok := ret.Get(0).(func(client.ApiInsertVirtualMediaRequest) client.RedfishError); ok {
		r0 = rf(_a0)
	} else {
		r0 = ret.Get(0).(client.RedfishError)
	}

	var r1 *http.Response
	if rf, ok := ret.Get(1).(func(client.ApiInsertVirtualMediaRequest) *http.Response); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*http.Response)
		}
	}

	var r2 error
	if rf, ok := ret.Get(2).(func(client.ApiInsertVirtualMediaRequest) error); ok {
		r2 = rf(_a0)
	} else {
		r2 = ret.Error(2)
	}

	return r0, r1, r2
}

// ListManagerVirtualMedia provides a mock function with given fields: _a0, _a1
func (_m *RedfishAPI) ListManagerVirtualMedia(_a0 context.Context, _a1 string) client.ApiListManagerVirtualMediaRequest {
	ret := _m.Called(_a0, _a1)

	var r0 client.ApiListManagerVirtualMediaRequest
	if rf, ok := ret.Get(0).(func(context.Context, string) client.ApiListManagerVirtualMediaRequest); ok {
		r0 = rf(_a0, _a1)
	} else {
		r0 = ret.Get(0).(client.ApiListManagerVirtualMediaRequest)
	}

	return r0
}

// ListManagerVirtualMediaExecute provides a mock function with given fields: _a0
func (_m *RedfishAPI) ListManagerVirtualMediaExecute(_a0 client.ApiListManagerVirtualMediaRequest) (client.Collection, *http.Response, error) {
	ret := _m.Called(_a0)

	var r0 client.Collection
	if rf, ok := ret.Get(0).(func(client.ApiListManagerVirtualMediaRequest) client.Collection); ok {
		r0 = rf(_a0)
	} else {
		r0 = ret.Get(0).(client.Collection)
	}

	var r1 *http.Response
	if rf, ok := ret.Get(1).(func(client.ApiListManagerVirtualMediaRequest) *http.Response); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*http.Response)
		}
	}

	var r2 error
	if rf, ok := ret.Get(2).(func(client.ApiListManagerVirtualMediaRequest) error); ok {
		r2 = rf(_a0)
	} else {
		r2 = ret.Error(2)
	}

	return r0, r1, r2
}

// ListManagers provides a mock function with given fields: _a0
func (_m *RedfishAPI) ListManagers(_a0 context.Context) client.ApiListManagersRequest {
	ret := _m.Called(_a0)

	var r0 client.ApiListManagersRequest
	if rf, ok := ret.Get(0).(func(context.Context) client.ApiListManagersRequest); ok {
		r0 = rf(_a0)
	} else {
		r0 = ret.Get(0).(client.ApiListManagersRequest)
	}

	return r0
}

// ListManagersExecute provides a mock function with given fields: _a0
func (_m *RedfishAPI) ListManagersExecute(_a0 client.ApiListManagersRequest) (client.Collection, *http.Response, error) {
	ret := _m.Called(_a0)

	var r0 client.Collection
	if rf, ok := ret.Get(0).(func(client.ApiListManagersRequest) client.Collection); ok {
		r0 = rf(_a0)
	} else {
		r0 = ret.Get(0).(client.Collection)
	}

	var r1 *http.Response
	if rf, ok := ret.Get(1).(func(client.ApiListManagersRequest) *http.Response); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*http.Response)
		}
	}

	var r2 error
	if rf, ok := ret.Get(2).(func(client.ApiListManagersRequest) error); ok {
		r2 = rf(_a0)
	} else {
		r2 = ret.Error(2)
	}

	return r0, r1, r2
}

// ListSystems provides a mock function with given fields: _a0
func (_m *RedfishAPI) ListSystems(_a0 context.Context) client.ApiListSystemsRequest {
	ret := _m.Called(_a0)

	var r0 client.ApiListSystemsRequest
	if rf, ok := ret.Get(0).(func(context.Context) client.ApiListSystemsRequest); ok {
		r0 = rf(_a0)
	} else {
		r0 = ret.Get(0).(client.ApiListSystemsRequest)
	}

	return r0
}

// ListSystemsExecute provides a mock function with given fields: _a0
func (_m *RedfishAPI) ListSystemsExecute(_a0 client.ApiListSystemsRequest) (client.Collection, *http.Response, error) {
	ret := _m.Called(_a0)

	var r0 client.Collection
	if rf, ok := ret.Get(0).(func(client.ApiListSystemsRequest) client.Collection); ok {
		r0 = rf(_a0)
	} else {
		r0 = ret.Get(0).(client.Collection)
	}

	var r1 *http.Response
	if rf, ok := ret.Get(1).(func(client.ApiListSystemsRequest) *http.Response); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*http.Response)
		}
	}

	var r2 error
	if rf, ok := ret.Get(2).(func(client.ApiListSystemsRequest) error); ok {
		r2 = rf(_a0)
	} else {
		r2 = ret.Error(2)
	}

	return r0, r1, r2
}

// ResetIdrac provides a mock function with given fields: _a0
func (_m *RedfishAPI) ResetIdrac(_a0 context.Context) client.ApiResetIdracRequest {
	ret := _m.Called(_a0)

	var r0 client.ApiResetIdracRequest
	if rf, ok := ret.Get(0).(func(context.Context) client.ApiResetIdracRequest); ok {
		r0 = rf(_a0)
	} else {
		r0 = ret.Get(0).(client.ApiResetIdracRequest)
	}

	return r0
}

// ResetIdracExecute provides a mock function with given fields: _a0
func (_m *RedfishAPI) ResetIdracExecute(_a0 client.ApiResetIdracRequest) (*http.Response, error) {
	ret := _m.Called(_a0)

	var r0 *http.Response
	if rf, ok := ret.Get(0).(func(client.ApiResetIdracRequest) *http.Response); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*http.Response)
		}
	}

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

	return r0, r1
}

// ResetSystem provides a mock function with given fields: _a0, _a1
func (_m *RedfishAPI) ResetSystem(_a0 context.Context, _a1 string) client.ApiResetSystemRequest {
	ret := _m.Called(_a0, _a1)

	var r0 client.ApiResetSystemRequest
	if rf, ok := ret.Get(0).(func(context.Context, string) client.ApiResetSystemRequest); ok {
		r0 = rf(_a0, _a1)
	} else {
		r0 = ret.Get(0).(client.ApiResetSystemRequest)
	}

	return r0
}

// ResetSystemExecute provides a mock function with given fields: _a0
func (_m *RedfishAPI) ResetSystemExecute(_a0 client.ApiResetSystemRequest) (client.RedfishError, *http.Response, error) {
	ret := _m.Called(_a0)

	var r0 client.RedfishError
	if rf, ok := ret.Get(0).(func(client.ApiResetSystemRequest) client.RedfishError); ok {
		r0 = rf(_a0)
	} else {
		r0 = ret.Get(0).(client.RedfishError)
	}

	var r1 *http.Response
	if rf, ok := ret.Get(1).(func(client.ApiResetSystemRequest) *http.Response); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*http.Response)
		}
	}

	var r2 error
	if rf, ok := ret.Get(2).(func(client.ApiResetSystemRequest) error); ok {
		r2 = rf(_a0)
	} else {
		r2 = ret.Error(2)
	}

	return r0, r1, r2
}

// SetSystem provides a mock function with given fields: _a0, _a1
func (_m *RedfishAPI) SetSystem(_a0 context.Context, _a1 string) client.ApiSetSystemRequest {
	ret := _m.Called(_a0, _a1)

	var r0 client.ApiSetSystemRequest
	if rf, ok := ret.Get(0).(func(context.Context, string) client.ApiSetSystemRequest); ok {
		r0 = rf(_a0, _a1)
	} else {
		r0 = ret.Get(0).(client.ApiSetSystemRequest)
	}

	return r0
}

// SetSystemExecute provides a mock function with given fields: _a0
func (_m *RedfishAPI) SetSystemExecute(_a0 client.ApiSetSystemRequest) (client.ComputerSystem, *http.Response, error) {
	ret := _m.Called(_a0)

	var r0 client.ComputerSystem
	if rf, ok := ret.Get(0).(func(client.ApiSetSystemRequest) client.ComputerSystem); ok {
		r0 = rf(_a0)
	} else {
		r0 = ret.Get(0).(client.ComputerSystem)
	}

	var r1 *http.Response
	if rf, ok := ret.Get(1).(func(client.ApiSetSystemRequest) *http.Response); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*http.Response)
		}
	}

	var r2 error
	if rf, ok := ret.Get(2).(func(client.ApiSetSystemRequest) error); ok {
		r2 = rf(_a0)
	} else {
		r2 = ret.Error(2)
	}

	return r0, r1, r2
}

// UpdateService provides a mock function with given fields: _a0
func (_m *RedfishAPI) UpdateService(_a0 context.Context) client.ApiUpdateServiceRequest {
	ret := _m.Called(_a0)

	var r0 client.ApiUpdateServiceRequest
	if rf, ok := ret.Get(0).(func(context.Context) client.ApiUpdateServiceRequest); ok {
		r0 = rf(_a0)
	} else {
		r0 = ret.Get(0).(client.ApiUpdateServiceRequest)
	}

	return r0
}

// UpdateServiceExecute provides a mock function with given fields: _a0
func (_m *RedfishAPI) UpdateServiceExecute(_a0 client.ApiUpdateServiceRequest) (client.UpdateService, *http.Response, error) {
	ret := _m.Called(_a0)

	var r0 client.UpdateService
	if rf, ok := ret.Get(0).(func(client.ApiUpdateServiceRequest) client.UpdateService); ok {
		r0 = rf(_a0)
	} else {
		r0 = ret.Get(0).(client.UpdateService)
	}

	var r1 *http.Response
	if rf, ok := ret.Get(1).(func(client.ApiUpdateServiceRequest) *http.Response); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*http.Response)
		}
	}

	var r2 error
	if rf, ok := ret.Get(2).(func(client.ApiUpdateServiceRequest) error); ok {
		r2 = rf(_a0)
	} else {
		r2 = ret.Error(2)
	}

	return r0, r1, r2
}

// UpdateServiceSimpleUpdate provides a mock function with given fields: _a0
func (_m *RedfishAPI) UpdateServiceSimpleUpdate(_a0 context.Context) client.ApiUpdateServiceSimpleUpdateRequest {
	ret := _m.Called(_a0)

	var r0 client.ApiUpdateServiceSimpleUpdateRequest
	if rf, ok := ret.Get(0).(func(context.Context) client.ApiUpdateServiceSimpleUpdateRequest); ok {
		r0 = rf(_a0)
	} else {
		r0 = ret.Get(0).(client.ApiUpdateServiceSimpleUpdateRequest)
	}

	return r0
}

// UpdateServiceSimpleUpdateExecute provides a mock function with given fields: _a0
func (_m *RedfishAPI) UpdateServiceSimpleUpdateExecute(_a0 client.ApiUpdateServiceSimpleUpdateRequest) (client.RedfishError, *http.Response, error) {
	ret := _m.Called(_a0)

	var r0 client.RedfishError
	if rf, ok := ret.Get(0).(func(client.ApiUpdateServiceSimpleUpdateRequest) client.RedfishError); ok {
		r0 = rf(_a0)
	} else {
		r0 = ret.Get(0).(client.RedfishError)
	}

	var r1 *http.Response
	if rf, ok := ret.Get(1).(func(client.ApiUpdateServiceSimpleUpdateRequest) *http.Response); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*http.Response)
		}
	}

	var r2 error
	if rf, ok := ret.Get(2).(func(client.ApiUpdateServiceSimpleUpdateRequest) error); ok {
		r2 = rf(_a0)
	} else {
		r2 = ret.Error(2)
	}

	return r0, r1, r2
}