// Code generated by moq; DO NOT EDIT.
// github.com/matryer/moq

package mock

import (
	"github.com/NVIDIA/go-nvml/pkg/nvml"
	"sync"
)

// Ensure, that Interface does implement nvml.Interface.
// If this is not the case, regenerate this file with moq.
var _ nvml.Interface = &Interface{}

// Interface is a mock implementation of nvml.Interface.
//
//	func TestSomethingThatUsesInterface(t *testing.T) {
//
//		// make and configure a mocked nvml.Interface
//		mockedInterface := &Interface{
//			ComputeInstanceDestroyFunc: func(computeInstance nvml.ComputeInstance) nvml.Return {
//				panic("mock out the ComputeInstanceDestroy method")
//			},
//			ComputeInstanceGetInfoFunc: func(computeInstance nvml.ComputeInstance) (nvml.ComputeInstanceInfo, nvml.Return) {
//				panic("mock out the ComputeInstanceGetInfo method")
//			},
//			DeviceClearAccountingPidsFunc: func(device nvml.Device) nvml.Return {
//				panic("mock out the DeviceClearAccountingPids method")
//			},
//			DeviceClearCpuAffinityFunc: func(device nvml.Device) nvml.Return {
//				panic("mock out the DeviceClearCpuAffinity method")
//			},
//			DeviceClearEccErrorCountsFunc: func(device nvml.Device, eccCounterType nvml.EccCounterType) nvml.Return {
//				panic("mock out the DeviceClearEccErrorCounts method")
//			},
//			DeviceClearFieldValuesFunc: func(device nvml.Device, fieldValues []nvml.FieldValue) nvml.Return {
//				panic("mock out the DeviceClearFieldValues method")
//			},
//			DeviceCreateGpuInstanceFunc: func(device nvml.Device, gpuInstanceProfileInfo *nvml.GpuInstanceProfileInfo) (nvml.GpuInstance, nvml.Return) {
//				panic("mock out the DeviceCreateGpuInstance method")
//			},
//			DeviceCreateGpuInstanceWithPlacementFunc: func(device nvml.Device, gpuInstanceProfileInfo *nvml.GpuInstanceProfileInfo, gpuInstancePlacement *nvml.GpuInstancePlacement) (nvml.GpuInstance, nvml.Return) {
//				panic("mock out the DeviceCreateGpuInstanceWithPlacement method")
//			},
//			DeviceDiscoverGpusFunc: func() (nvml.PciInfo, nvml.Return) {
//				panic("mock out the DeviceDiscoverGpus method")
//			},
//			DeviceFreezeNvLinkUtilizationCounterFunc: func(device nvml.Device, n1 int, n2 int, enableState nvml.EnableState) nvml.Return {
//				panic("mock out the DeviceFreezeNvLinkUtilizationCounter method")
//			},
//			DeviceGetAPIRestrictionFunc: func(device nvml.Device, restrictedAPI nvml.RestrictedAPI) (nvml.EnableState, nvml.Return) {
//				panic("mock out the DeviceGetAPIRestriction method")
//			},
//			DeviceGetAccountingBufferSizeFunc: func(device nvml.Device) (int, nvml.Return) {
//				panic("mock out the DeviceGetAccountingBufferSize method")
//			},
//			DeviceGetAccountingModeFunc: func(device nvml.Device) (nvml.EnableState, nvml.Return) {
//				panic("mock out the DeviceGetAccountingMode method")
//			},
//			DeviceGetAccountingPidsFunc: func(device nvml.Device) ([]int, nvml.Return) {
//				panic("mock out the DeviceGetAccountingPids method")
//			},
//			DeviceGetAccountingStatsFunc: func(device nvml.Device, v uint32) (nvml.AccountingStats, nvml.Return) {
//				panic("mock out the DeviceGetAccountingStats method")
//			},
//			DeviceGetActiveVgpusFunc: func(device nvml.Device) ([]nvml.VgpuInstance, nvml.Return) {
//				panic("mock out the DeviceGetActiveVgpus method")
//			},
//			DeviceGetAdaptiveClockInfoStatusFunc: func(device nvml.Device) (uint32, nvml.Return) {
//				panic("mock out the DeviceGetAdaptiveClockInfoStatus method")
//			},
//			DeviceGetAddressingModeFunc: func(device nvml.Device) (nvml.DeviceAddressingMode, nvml.Return) {
//				panic("mock out the DeviceGetAddressingMode method")
//			},
//			DeviceGetApplicationsClockFunc: func(device nvml.Device, clockType nvml.ClockType) (uint32, nvml.Return) {
//				panic("mock out the DeviceGetApplicationsClock method")
//			},
//			DeviceGetArchitectureFunc: func(device nvml.Device) (nvml.DeviceArchitecture, nvml.Return) {
//				panic("mock out the DeviceGetArchitecture method")
//			},
//			DeviceGetAttributesFunc: func(device nvml.Device) (nvml.DeviceAttributes, nvml.Return) {
//				panic("mock out the DeviceGetAttributes method")
//			},
//			DeviceGetAutoBoostedClocksEnabledFunc: func(device nvml.Device) (nvml.EnableState, nvml.EnableState, nvml.Return) {
//				panic("mock out the DeviceGetAutoBoostedClocksEnabled method")
//			},
//			DeviceGetBAR1MemoryInfoFunc: func(device nvml.Device) (nvml.BAR1Memory, nvml.Return) {
//				panic("mock out the DeviceGetBAR1MemoryInfo method")
//			},
//			DeviceGetBoardIdFunc: func(device nvml.Device) (uint32, nvml.Return) {
//				panic("mock out the DeviceGetBoardId method")
//			},
//			DeviceGetBoardPartNumberFunc: func(device nvml.Device) (string, nvml.Return) {
//				panic("mock out the DeviceGetBoardPartNumber method")
//			},
//			DeviceGetBrandFunc: func(device nvml.Device) (nvml.BrandType, nvml.Return) {
//				panic("mock out the DeviceGetBrand method")
//			},
//			DeviceGetBridgeChipInfoFunc: func(device nvml.Device) (nvml.BridgeChipHierarchy, nvml.Return) {
//				panic("mock out the DeviceGetBridgeChipInfo method")
//			},
//			DeviceGetBusTypeFunc: func(device nvml.Device) (nvml.BusType, nvml.Return) {
//				panic("mock out the DeviceGetBusType method")
//			},
//			DeviceGetC2cModeInfoVFunc: func(device nvml.Device) nvml.C2cModeInfoHandler {
//				panic("mock out the DeviceGetC2cModeInfoV method")
//			},
//			DeviceGetCapabilitiesFunc: func(device nvml.Device) (nvml.DeviceCapabilities, nvml.Return) {
//				panic("mock out the DeviceGetCapabilities method")
//			},
//			DeviceGetClkMonStatusFunc: func(device nvml.Device) (nvml.ClkMonStatus, nvml.Return) {
//				panic("mock out the DeviceGetClkMonStatus method")
//			},
//			DeviceGetClockFunc: func(device nvml.Device, clockType nvml.ClockType, clockId nvml.ClockId) (uint32, nvml.Return) {
//				panic("mock out the DeviceGetClock method")
//			},
//			DeviceGetClockInfoFunc: func(device nvml.Device, clockType nvml.ClockType) (uint32, nvml.Return) {
//				panic("mock out the DeviceGetClockInfo method")
//			},
//			DeviceGetClockOffsetsFunc: func(device nvml.Device) (nvml.ClockOffset, nvml.Return) {
//				panic("mock out the DeviceGetClockOffsets method")
//			},
//			DeviceGetComputeInstanceIdFunc: func(device nvml.Device) (int, nvml.Return) {
//				panic("mock out the DeviceGetComputeInstanceId method")
//			},
//			DeviceGetComputeModeFunc: func(device nvml.Device) (nvml.ComputeMode, nvml.Return) {
//				panic("mock out the DeviceGetComputeMode method")
//			},
//			DeviceGetComputeRunningProcessesFunc: func(device nvml.Device) ([]nvml.ProcessInfo, nvml.Return) {
//				panic("mock out the DeviceGetComputeRunningProcesses method")
//			},
//			DeviceGetConfComputeGpuAttestationReportFunc: func(device nvml.Device, confComputeGpuAttestationReport *nvml.ConfComputeGpuAttestationReport) nvml.Return {
//				panic("mock out the DeviceGetConfComputeGpuAttestationReport method")
//			},
//			DeviceGetConfComputeGpuCertificateFunc: func(device nvml.Device) (nvml.ConfComputeGpuCertificate, nvml.Return) {
//				panic("mock out the DeviceGetConfComputeGpuCertificate method")
//			},
//			DeviceGetConfComputeMemSizeInfoFunc: func(device nvml.Device) (nvml.ConfComputeMemSizeInfo, nvml.Return) {
//				panic("mock out the DeviceGetConfComputeMemSizeInfo method")
//			},
//			DeviceGetConfComputeProtectedMemoryUsageFunc: func(device nvml.Device) (nvml.Memory, nvml.Return) {
//				panic("mock out the DeviceGetConfComputeProtectedMemoryUsage method")
//			},
//			DeviceGetCoolerInfoFunc: func(device nvml.Device) (nvml.CoolerInfo, nvml.Return) {
//				panic("mock out the DeviceGetCoolerInfo method")
//			},
//			DeviceGetCountFunc: func() (int, nvml.Return) {
//				panic("mock out the DeviceGetCount method")
//			},
//			DeviceGetCpuAffinityFunc: func(device nvml.Device, n int) ([]uint, nvml.Return) {
//				panic("mock out the DeviceGetCpuAffinity method")
//			},
//			DeviceGetCpuAffinityWithinScopeFunc: func(device nvml.Device, n int, affinityScope nvml.AffinityScope) ([]uint, nvml.Return) {
//				panic("mock out the DeviceGetCpuAffinityWithinScope method")
//			},
//			DeviceGetCreatableVgpusFunc: func(device nvml.Device) ([]nvml.VgpuTypeId, nvml.Return) {
//				panic("mock out the DeviceGetCreatableVgpus method")
//			},
//			DeviceGetCudaComputeCapabilityFunc: func(device nvml.Device) (int, int, nvml.Return) {
//				panic("mock out the DeviceGetCudaComputeCapability method")
//			},
//			DeviceGetCurrPcieLinkGenerationFunc: func(device nvml.Device) (int, nvml.Return) {
//				panic("mock out the DeviceGetCurrPcieLinkGeneration method")
//			},
//			DeviceGetCurrPcieLinkWidthFunc: func(device nvml.Device) (int, nvml.Return) {
//				panic("mock out the DeviceGetCurrPcieLinkWidth method")
//			},
//			DeviceGetCurrentClockFreqsFunc: func(device nvml.Device) (nvml.DeviceCurrentClockFreqs, nvml.Return) {
//				panic("mock out the DeviceGetCurrentClockFreqs method")
//			},
//			DeviceGetCurrentClocksEventReasonsFunc: func(device nvml.Device) (uint64, nvml.Return) {
//				panic("mock out the DeviceGetCurrentClocksEventReasons method")
//			},
//			DeviceGetCurrentClocksThrottleReasonsFunc: func(device nvml.Device) (uint64, nvml.Return) {
//				panic("mock out the DeviceGetCurrentClocksThrottleReasons method")
//			},
//			DeviceGetDecoderUtilizationFunc: func(device nvml.Device) (uint32, uint32, nvml.Return) {
//				panic("mock out the DeviceGetDecoderUtilization method")
//			},
//			DeviceGetDefaultApplicationsClockFunc: func(device nvml.Device, clockType nvml.ClockType) (uint32, nvml.Return) {
//				panic("mock out the DeviceGetDefaultApplicationsClock method")
//			},
//			DeviceGetDefaultEccModeFunc: func(device nvml.Device) (nvml.EnableState, nvml.Return) {
//				panic("mock out the DeviceGetDefaultEccMode method")
//			},
//			DeviceGetDetailedEccErrorsFunc: func(device nvml.Device, memoryErrorType nvml.MemoryErrorType, eccCounterType nvml.EccCounterType) (nvml.EccErrorCounts, nvml.Return) {
//				panic("mock out the DeviceGetDetailedEccErrors method")
//			},
//			DeviceGetDeviceHandleFromMigDeviceHandleFunc: func(device nvml.Device) (nvml.Device, nvml.Return) {
//				panic("mock out the DeviceGetDeviceHandleFromMigDeviceHandle method")
//			},
//			DeviceGetDisplayActiveFunc: func(device nvml.Device) (nvml.EnableState, nvml.Return) {
//				panic("mock out the DeviceGetDisplayActive method")
//			},
//			DeviceGetDisplayModeFunc: func(device nvml.Device) (nvml.EnableState, nvml.Return) {
//				panic("mock out the DeviceGetDisplayMode method")
//			},
//			DeviceGetDramEncryptionModeFunc: func(device nvml.Device) (nvml.DramEncryptionInfo, nvml.DramEncryptionInfo, nvml.Return) {
//				panic("mock out the DeviceGetDramEncryptionMode method")
//			},
//			DeviceGetDriverModelFunc: func(device nvml.Device) (nvml.DriverModel, nvml.DriverModel, nvml.Return) {
//				panic("mock out the DeviceGetDriverModel method")
//			},
//			DeviceGetDriverModel_v2Func: func(device nvml.Device) (nvml.DriverModel, nvml.DriverModel, nvml.Return) {
//				panic("mock out the DeviceGetDriverModel_v2 method")
//			},
//			DeviceGetDynamicPstatesInfoFunc: func(device nvml.Device) (nvml.GpuDynamicPstatesInfo, nvml.Return) {
//				panic("mock out the DeviceGetDynamicPstatesInfo method")
//			},
//			DeviceGetEccModeFunc: func(device nvml.Device) (nvml.EnableState, nvml.EnableState, nvml.Return) {
//				panic("mock out the DeviceGetEccMode method")
//			},
//			DeviceGetEncoderCapacityFunc: func(device nvml.Device, encoderType nvml.EncoderType) (int, nvml.Return) {
//				panic("mock out the DeviceGetEncoderCapacity method")
//			},
//			DeviceGetEncoderSessionsFunc: func(device nvml.Device) ([]nvml.EncoderSessionInfo, nvml.Return) {
//				panic("mock out the DeviceGetEncoderSessions method")
//			},
//			DeviceGetEncoderStatsFunc: func(device nvml.Device) (int, uint32, uint32, nvml.Return) {
//				panic("mock out the DeviceGetEncoderStats method")
//			},
//			DeviceGetEncoderUtilizationFunc: func(device nvml.Device) (uint32, uint32, nvml.Return) {
//				panic("mock out the DeviceGetEncoderUtilization method")
//			},
//			DeviceGetEnforcedPowerLimitFunc: func(device nvml.Device) (uint32, nvml.Return) {
//				panic("mock out the DeviceGetEnforcedPowerLimit method")
//			},
//			DeviceGetFBCSessionsFunc: func(device nvml.Device) ([]nvml.FBCSessionInfo, nvml.Return) {
//				panic("mock out the DeviceGetFBCSessions method")
//			},
//			DeviceGetFBCStatsFunc: func(device nvml.Device) (nvml.FBCStats, nvml.Return) {
//				panic("mock out the DeviceGetFBCStats method")
//			},
//			DeviceGetFanControlPolicy_v2Func: func(device nvml.Device, n int) (nvml.FanControlPolicy, nvml.Return) {
//				panic("mock out the DeviceGetFanControlPolicy_v2 method")
//			},
//			DeviceGetFanSpeedFunc: func(device nvml.Device) (uint32, nvml.Return) {
//				panic("mock out the DeviceGetFanSpeed method")
//			},
//			DeviceGetFanSpeedRPMFunc: func(device nvml.Device) (nvml.FanSpeedInfo, nvml.Return) {
//				panic("mock out the DeviceGetFanSpeedRPM method")
//			},
//			DeviceGetFanSpeed_v2Func: func(device nvml.Device, n int) (uint32, nvml.Return) {
//				panic("mock out the DeviceGetFanSpeed_v2 method")
//			},
//			DeviceGetFieldValuesFunc: func(device nvml.Device, fieldValues []nvml.FieldValue) nvml.Return {
//				panic("mock out the DeviceGetFieldValues method")
//			},
//			DeviceGetGpcClkMinMaxVfOffsetFunc: func(device nvml.Device) (int, int, nvml.Return) {
//				panic("mock out the DeviceGetGpcClkMinMaxVfOffset method")
//			},
//			DeviceGetGpcClkVfOffsetFunc: func(device nvml.Device) (int, nvml.Return) {
//				panic("mock out the DeviceGetGpcClkVfOffset method")
//			},
//			DeviceGetGpuFabricInfoFunc: func(device nvml.Device) (nvml.GpuFabricInfo, nvml.Return) {
//				panic("mock out the DeviceGetGpuFabricInfo method")
//			},
//			DeviceGetGpuFabricInfoVFunc: func(device nvml.Device) nvml.GpuFabricInfoHandler {
//				panic("mock out the DeviceGetGpuFabricInfoV method")
//			},
//			DeviceGetGpuInstanceByIdFunc: func(device nvml.Device, n int) (nvml.GpuInstance, nvml.Return) {
//				panic("mock out the DeviceGetGpuInstanceById method")
//			},
//			DeviceGetGpuInstanceIdFunc: func(device nvml.Device) (int, nvml.Return) {
//				panic("mock out the DeviceGetGpuInstanceId method")
//			},
//			DeviceGetGpuInstancePossiblePlacementsFunc: func(device nvml.Device, gpuInstanceProfileInfo *nvml.GpuInstanceProfileInfo) ([]nvml.GpuInstancePlacement, nvml.Return) {
//				panic("mock out the DeviceGetGpuInstancePossiblePlacements method")
//			},
//			DeviceGetGpuInstanceProfileInfoFunc: func(device nvml.Device, n int) (nvml.GpuInstanceProfileInfo, nvml.Return) {
//				panic("mock out the DeviceGetGpuInstanceProfileInfo method")
//			},
//			DeviceGetGpuInstanceProfileInfoByIdVFunc: func(device nvml.Device, n int) nvml.GpuInstanceProfileInfoByIdHandler {
//				panic("mock out the DeviceGetGpuInstanceProfileInfoByIdV method")
//			},
//			DeviceGetGpuInstanceProfileInfoVFunc: func(device nvml.Device, n int) nvml.GpuInstanceProfileInfoHandler {
//				panic("mock out the DeviceGetGpuInstanceProfileInfoV method")
//			},
//			DeviceGetGpuInstanceRemainingCapacityFunc: func(device nvml.Device, gpuInstanceProfileInfo *nvml.GpuInstanceProfileInfo) (int, nvml.Return) {
//				panic("mock out the DeviceGetGpuInstanceRemainingCapacity method")
//			},
//			DeviceGetGpuInstancesFunc: func(device nvml.Device, gpuInstanceProfileInfo *nvml.GpuInstanceProfileInfo) ([]nvml.GpuInstance, nvml.Return) {
//				panic("mock out the DeviceGetGpuInstances method")
//			},
//			DeviceGetGpuMaxPcieLinkGenerationFunc: func(device nvml.Device) (int, nvml.Return) {
//				panic("mock out the DeviceGetGpuMaxPcieLinkGeneration method")
//			},
//			DeviceGetGpuOperationModeFunc: func(device nvml.Device) (nvml.GpuOperationMode, nvml.GpuOperationMode, nvml.Return) {
//				panic("mock out the DeviceGetGpuOperationMode method")
//			},
//			DeviceGetGraphicsRunningProcessesFunc: func(device nvml.Device) ([]nvml.ProcessInfo, nvml.Return) {
//				panic("mock out the DeviceGetGraphicsRunningProcesses method")
//			},
//			DeviceGetGridLicensableFeaturesFunc: func(device nvml.Device) (nvml.GridLicensableFeatures, nvml.Return) {
//				panic("mock out the DeviceGetGridLicensableFeatures method")
//			},
//			DeviceGetGspFirmwareModeFunc: func(device nvml.Device) (bool, bool, nvml.Return) {
//				panic("mock out the DeviceGetGspFirmwareMode method")
//			},
//			DeviceGetGspFirmwareVersionFunc: func(device nvml.Device) (string, nvml.Return) {
//				panic("mock out the DeviceGetGspFirmwareVersion method")
//			},
//			DeviceGetHandleByIndexFunc: func(n int) (nvml.Device, nvml.Return) {
//				panic("mock out the DeviceGetHandleByIndex method")
//			},
//			DeviceGetHandleByPciBusIdFunc: func(s string) (nvml.Device, nvml.Return) {
//				panic("mock out the DeviceGetHandleByPciBusId method")
//			},
//			DeviceGetHandleBySerialFunc: func(s string) (nvml.Device, nvml.Return) {
//				panic("mock out the DeviceGetHandleBySerial method")
//			},
//			DeviceGetHandleByUUIDFunc: func(s string) (nvml.Device, nvml.Return) {
//				panic("mock out the DeviceGetHandleByUUID method")
//			},
//			DeviceGetHandleByUUIDVFunc: func(uUID *nvml.UUID) (nvml.Device, nvml.Return) {
//				panic("mock out the DeviceGetHandleByUUIDV method")
//			},
//			DeviceGetHostVgpuModeFunc: func(device nvml.Device) (nvml.HostVgpuMode, nvml.Return) {
//				panic("mock out the DeviceGetHostVgpuMode method")
//			},
//			DeviceGetIndexFunc: func(device nvml.Device) (int, nvml.Return) {
//				panic("mock out the DeviceGetIndex method")
//			},
//			DeviceGetInforomConfigurationChecksumFunc: func(device nvml.Device) (uint32, nvml.Return) {
//				panic("mock out the DeviceGetInforomConfigurationChecksum method")
//			},
//			DeviceGetInforomImageVersionFunc: func(device nvml.Device) (string, nvml.Return) {
//				panic("mock out the DeviceGetInforomImageVersion method")
//			},
//			DeviceGetInforomVersionFunc: func(device nvml.Device, inforomObject nvml.InforomObject) (string, nvml.Return) {
//				panic("mock out the DeviceGetInforomVersion method")
//			},
//			DeviceGetIrqNumFunc: func(device nvml.Device) (int, nvml.Return) {
//				panic("mock out the DeviceGetIrqNum method")
//			},
//			DeviceGetJpgUtilizationFunc: func(device nvml.Device) (uint32, uint32, nvml.Return) {
//				panic("mock out the DeviceGetJpgUtilization method")
//			},
//			DeviceGetLastBBXFlushTimeFunc: func(device nvml.Device) (uint64, uint, nvml.Return) {
//				panic("mock out the DeviceGetLastBBXFlushTime method")
//			},
//			DeviceGetMPSComputeRunningProcessesFunc: func(device nvml.Device) ([]nvml.ProcessInfo, nvml.Return) {
//				panic("mock out the DeviceGetMPSComputeRunningProcesses method")
//			},
//			DeviceGetMarginTemperatureFunc: func(device nvml.Device) (nvml.MarginTemperature, nvml.Return) {
//				panic("mock out the DeviceGetMarginTemperature method")
//			},
//			DeviceGetMaxClockInfoFunc: func(device nvml.Device, clockType nvml.ClockType) (uint32, nvml.Return) {
//				panic("mock out the DeviceGetMaxClockInfo method")
//			},
//			DeviceGetMaxCustomerBoostClockFunc: func(device nvml.Device, clockType nvml.ClockType) (uint32, nvml.Return) {
//				panic("mock out the DeviceGetMaxCustomerBoostClock method")
//			},
//			DeviceGetMaxMigDeviceCountFunc: func(device nvml.Device) (int, nvml.Return) {
//				panic("mock out the DeviceGetMaxMigDeviceCount method")
//			},
//			DeviceGetMaxPcieLinkGenerationFunc: func(device nvml.Device) (int, nvml.Return) {
//				panic("mock out the DeviceGetMaxPcieLinkGeneration method")
//			},
//			DeviceGetMaxPcieLinkWidthFunc: func(device nvml.Device) (int, nvml.Return) {
//				panic("mock out the DeviceGetMaxPcieLinkWidth method")
//			},
//			DeviceGetMemClkMinMaxVfOffsetFunc: func(device nvml.Device) (int, int, nvml.Return) {
//				panic("mock out the DeviceGetMemClkMinMaxVfOffset method")
//			},
//			DeviceGetMemClkVfOffsetFunc: func(device nvml.Device) (int, nvml.Return) {
//				panic("mock out the DeviceGetMemClkVfOffset method")
//			},
//			DeviceGetMemoryAffinityFunc: func(device nvml.Device, n int, affinityScope nvml.AffinityScope) ([]uint, nvml.Return) {
//				panic("mock out the DeviceGetMemoryAffinity method")
//			},
//			DeviceGetMemoryBusWidthFunc: func(device nvml.Device) (uint32, nvml.Return) {
//				panic("mock out the DeviceGetMemoryBusWidth method")
//			},
//			DeviceGetMemoryErrorCounterFunc: func(device nvml.Device, memoryErrorType nvml.MemoryErrorType, eccCounterType nvml.EccCounterType, memoryLocation nvml.MemoryLocation) (uint64, nvml.Return) {
//				panic("mock out the DeviceGetMemoryErrorCounter method")
//			},
//			DeviceGetMemoryInfoFunc: func(device nvml.Device) (nvml.Memory, nvml.Return) {
//				panic("mock out the DeviceGetMemoryInfo method")
//			},
//			DeviceGetMemoryInfo_v2Func: func(device nvml.Device) (nvml.Memory_v2, nvml.Return) {
//				panic("mock out the DeviceGetMemoryInfo_v2 method")
//			},
//			DeviceGetMigDeviceHandleByIndexFunc: func(device nvml.Device, n int) (nvml.Device, nvml.Return) {
//				panic("mock out the DeviceGetMigDeviceHandleByIndex method")
//			},
//			DeviceGetMigModeFunc: func(device nvml.Device) (int, int, nvml.Return) {
//				panic("mock out the DeviceGetMigMode method")
//			},
//			DeviceGetMinMaxClockOfPStateFunc: func(device nvml.Device, clockType nvml.ClockType, pstates nvml.Pstates) (uint32, uint32, nvml.Return) {
//				panic("mock out the DeviceGetMinMaxClockOfPState method")
//			},
//			DeviceGetMinMaxFanSpeedFunc: func(device nvml.Device) (int, int, nvml.Return) {
//				panic("mock out the DeviceGetMinMaxFanSpeed method")
//			},
//			DeviceGetMinorNumberFunc: func(device nvml.Device) (int, nvml.Return) {
//				panic("mock out the DeviceGetMinorNumber method")
//			},
//			DeviceGetModuleIdFunc: func(device nvml.Device) (int, nvml.Return) {
//				panic("mock out the DeviceGetModuleId method")
//			},
//			DeviceGetMultiGpuBoardFunc: func(device nvml.Device) (int, nvml.Return) {
//				panic("mock out the DeviceGetMultiGpuBoard method")
//			},
//			DeviceGetNameFunc: func(device nvml.Device) (string, nvml.Return) {
//				panic("mock out the DeviceGetName method")
//			},
//			DeviceGetNumFansFunc: func(device nvml.Device) (int, nvml.Return) {
//				panic("mock out the DeviceGetNumFans method")
//			},
//			DeviceGetNumGpuCoresFunc: func(device nvml.Device) (int, nvml.Return) {
//				panic("mock out the DeviceGetNumGpuCores method")
//			},
//			DeviceGetNumaNodeIdFunc: func(device nvml.Device) (int, nvml.Return) {
//				panic("mock out the DeviceGetNumaNodeId method")
//			},
//			DeviceGetNvLinkCapabilityFunc: func(device nvml.Device, n int, nvLinkCapability nvml.NvLinkCapability) (uint32, nvml.Return) {
//				panic("mock out the DeviceGetNvLinkCapability method")
//			},
//			DeviceGetNvLinkErrorCounterFunc: func(device nvml.Device, n int, nvLinkErrorCounter nvml.NvLinkErrorCounter) (uint64, nvml.Return) {
//				panic("mock out the DeviceGetNvLinkErrorCounter method")
//			},
//			DeviceGetNvLinkInfoFunc: func(device nvml.Device) nvml.NvLinkInfoHandler {
//				panic("mock out the DeviceGetNvLinkInfo method")
//			},
//			DeviceGetNvLinkRemoteDeviceTypeFunc: func(device nvml.Device, n int) (nvml.IntNvLinkDeviceType, nvml.Return) {
//				panic("mock out the DeviceGetNvLinkRemoteDeviceType method")
//			},
//			DeviceGetNvLinkRemotePciInfoFunc: func(device nvml.Device, n int) (nvml.PciInfo, nvml.Return) {
//				panic("mock out the DeviceGetNvLinkRemotePciInfo method")
//			},
//			DeviceGetNvLinkStateFunc: func(device nvml.Device, n int) (nvml.EnableState, nvml.Return) {
//				panic("mock out the DeviceGetNvLinkState method")
//			},
//			DeviceGetNvLinkUtilizationControlFunc: func(device nvml.Device, n1 int, n2 int) (nvml.NvLinkUtilizationControl, nvml.Return) {
//				panic("mock out the DeviceGetNvLinkUtilizationControl method")
//			},
//			DeviceGetNvLinkUtilizationCounterFunc: func(device nvml.Device, n1 int, n2 int) (uint64, uint64, nvml.Return) {
//				panic("mock out the DeviceGetNvLinkUtilizationCounter method")
//			},
//			DeviceGetNvLinkVersionFunc: func(device nvml.Device, n int) (uint32, nvml.Return) {
//				panic("mock out the DeviceGetNvLinkVersion method")
//			},
//			DeviceGetNvlinkBwModeFunc: func(device nvml.Device) (nvml.NvlinkGetBwMode, nvml.Return) {
//				panic("mock out the DeviceGetNvlinkBwMode method")
//			},
//			DeviceGetNvlinkSupportedBwModesFunc: func(device nvml.Device) (nvml.NvlinkSupportedBwModes, nvml.Return) {
//				panic("mock out the DeviceGetNvlinkSupportedBwModes method")
//			},
//			DeviceGetOfaUtilizationFunc: func(device nvml.Device) (uint32, uint32, nvml.Return) {
//				panic("mock out the DeviceGetOfaUtilization method")
//			},
//			DeviceGetP2PStatusFunc: func(device1 nvml.Device, device2 nvml.Device, gpuP2PCapsIndex nvml.GpuP2PCapsIndex) (nvml.GpuP2PStatus, nvml.Return) {
//				panic("mock out the DeviceGetP2PStatus method")
//			},
//			DeviceGetPciInfoFunc: func(device nvml.Device) (nvml.PciInfo, nvml.Return) {
//				panic("mock out the DeviceGetPciInfo method")
//			},
//			DeviceGetPciInfoExtFunc: func(device nvml.Device) (nvml.PciInfoExt, nvml.Return) {
//				panic("mock out the DeviceGetPciInfoExt method")
//			},
//			DeviceGetPcieLinkMaxSpeedFunc: func(device nvml.Device) (uint32, nvml.Return) {
//				panic("mock out the DeviceGetPcieLinkMaxSpeed method")
//			},
//			DeviceGetPcieReplayCounterFunc: func(device nvml.Device) (int, nvml.Return) {
//				panic("mock out the DeviceGetPcieReplayCounter method")
//			},
//			DeviceGetPcieSpeedFunc: func(device nvml.Device) (int, nvml.Return) {
//				panic("mock out the DeviceGetPcieSpeed method")
//			},
//			DeviceGetPcieThroughputFunc: func(device nvml.Device, pcieUtilCounter nvml.PcieUtilCounter) (uint32, nvml.Return) {
//				panic("mock out the DeviceGetPcieThroughput method")
//			},
//			DeviceGetPdiFunc: func(device nvml.Device) (nvml.Pdi, nvml.Return) {
//				panic("mock out the DeviceGetPdi method")
//			},
//			DeviceGetPerformanceModesFunc: func(device nvml.Device) (nvml.DevicePerfModes, nvml.Return) {
//				panic("mock out the DeviceGetPerformanceModes method")
//			},
//			DeviceGetPerformanceStateFunc: func(device nvml.Device) (nvml.Pstates, nvml.Return) {
//				panic("mock out the DeviceGetPerformanceState method")
//			},
//			DeviceGetPersistenceModeFunc: func(device nvml.Device) (nvml.EnableState, nvml.Return) {
//				panic("mock out the DeviceGetPersistenceMode method")
//			},
//			DeviceGetPgpuMetadataStringFunc: func(device nvml.Device) (string, nvml.Return) {
//				panic("mock out the DeviceGetPgpuMetadataString method")
//			},
//			DeviceGetPlatformInfoFunc: func(device nvml.Device) (nvml.PlatformInfo, nvml.Return) {
//				panic("mock out the DeviceGetPlatformInfo method")
//			},
//			DeviceGetPowerManagementDefaultLimitFunc: func(device nvml.Device) (uint32, nvml.Return) {
//				panic("mock out the DeviceGetPowerManagementDefaultLimit method")
//			},
//			DeviceGetPowerManagementLimitFunc: func(device nvml.Device) (uint32, nvml.Return) {
//				panic("mock out the DeviceGetPowerManagementLimit method")
//			},
//			DeviceGetPowerManagementLimitConstraintsFunc: func(device nvml.Device) (uint32, uint32, nvml.Return) {
//				panic("mock out the DeviceGetPowerManagementLimitConstraints method")
//			},
//			DeviceGetPowerManagementModeFunc: func(device nvml.Device) (nvml.EnableState, nvml.Return) {
//				panic("mock out the DeviceGetPowerManagementMode method")
//			},
//			DeviceGetPowerMizerMode_v1Func: func(device nvml.Device) (nvml.DevicePowerMizerModes_v1, nvml.Return) {
//				panic("mock out the DeviceGetPowerMizerMode_v1 method")
//			},
//			DeviceGetPowerSourceFunc: func(device nvml.Device) (nvml.PowerSource, nvml.Return) {
//				panic("mock out the DeviceGetPowerSource method")
//			},
//			DeviceGetPowerStateFunc: func(device nvml.Device) (nvml.Pstates, nvml.Return) {
//				panic("mock out the DeviceGetPowerState method")
//			},
//			DeviceGetPowerUsageFunc: func(device nvml.Device) (uint32, nvml.Return) {
//				panic("mock out the DeviceGetPowerUsage method")
//			},
//			DeviceGetProcessUtilizationFunc: func(device nvml.Device, v uint64) ([]nvml.ProcessUtilizationSample, nvml.Return) {
//				panic("mock out the DeviceGetProcessUtilization method")
//			},
//			DeviceGetProcessesUtilizationInfoFunc: func(device nvml.Device) (nvml.ProcessesUtilizationInfo, nvml.Return) {
//				panic("mock out the DeviceGetProcessesUtilizationInfo method")
//			},
//			DeviceGetRemappedRowsFunc: func(device nvml.Device) (int, int, bool, bool, nvml.Return) {
//				panic("mock out the DeviceGetRemappedRows method")
//			},
//			DeviceGetRepairStatusFunc: func(device nvml.Device) (nvml.RepairStatus, nvml.Return) {
//				panic("mock out the DeviceGetRepairStatus method")
//			},
//			DeviceGetRetiredPagesFunc: func(device nvml.Device, pageRetirementCause nvml.PageRetirementCause) ([]uint64, nvml.Return) {
//				panic("mock out the DeviceGetRetiredPages method")
//			},
//			DeviceGetRetiredPagesPendingStatusFunc: func(device nvml.Device) (nvml.EnableState, nvml.Return) {
//				panic("mock out the DeviceGetRetiredPagesPendingStatus method")
//			},
//			DeviceGetRetiredPages_v2Func: func(device nvml.Device, pageRetirementCause nvml.PageRetirementCause) ([]uint64, []uint64, nvml.Return) {
//				panic("mock out the DeviceGetRetiredPages_v2 method")
//			},
//			DeviceGetRowRemapperHistogramFunc: func(device nvml.Device) (nvml.RowRemapperHistogramValues, nvml.Return) {
//				panic("mock out the DeviceGetRowRemapperHistogram method")
//			},
//			DeviceGetRunningProcessDetailListFunc: func(device nvml.Device) (nvml.ProcessDetailList, nvml.Return) {
//				panic("mock out the DeviceGetRunningProcessDetailList method")
//			},
//			DeviceGetSamplesFunc: func(device nvml.Device, samplingType nvml.SamplingType, v uint64) (nvml.ValueType, []nvml.Sample, nvml.Return) {
//				panic("mock out the DeviceGetSamples method")
//			},
//			DeviceGetSerialFunc: func(device nvml.Device) (string, nvml.Return) {
//				panic("mock out the DeviceGetSerial method")
//			},
//			DeviceGetSramEccErrorStatusFunc: func(device nvml.Device) (nvml.EccSramErrorStatus, nvml.Return) {
//				panic("mock out the DeviceGetSramEccErrorStatus method")
//			},
//			DeviceGetSramUniqueUncorrectedEccErrorCountsFunc: func(device nvml.Device, eccSramUniqueUncorrectedErrorCounts *nvml.EccSramUniqueUncorrectedErrorCounts) nvml.Return {
//				panic("mock out the DeviceGetSramUniqueUncorrectedEccErrorCounts method")
//			},
//			DeviceGetSupportedClocksEventReasonsFunc: func(device nvml.Device) (uint64, nvml.Return) {
//				panic("mock out the DeviceGetSupportedClocksEventReasons method")
//			},
//			DeviceGetSupportedClocksThrottleReasonsFunc: func(device nvml.Device) (uint64, nvml.Return) {
//				panic("mock out the DeviceGetSupportedClocksThrottleReasons method")
//			},
//			DeviceGetSupportedEventTypesFunc: func(device nvml.Device) (uint64, nvml.Return) {
//				panic("mock out the DeviceGetSupportedEventTypes method")
//			},
//			DeviceGetSupportedGraphicsClocksFunc: func(device nvml.Device, n int) (int, uint32, nvml.Return) {
//				panic("mock out the DeviceGetSupportedGraphicsClocks method")
//			},
//			DeviceGetSupportedMemoryClocksFunc: func(device nvml.Device) (int, uint32, nvml.Return) {
//				panic("mock out the DeviceGetSupportedMemoryClocks method")
//			},
//			DeviceGetSupportedPerformanceStatesFunc: func(device nvml.Device) ([]nvml.Pstates, nvml.Return) {
//				panic("mock out the DeviceGetSupportedPerformanceStates method")
//			},
//			DeviceGetSupportedVgpusFunc: func(device nvml.Device) ([]nvml.VgpuTypeId, nvml.Return) {
//				panic("mock out the DeviceGetSupportedVgpus method")
//			},
//			DeviceGetTargetFanSpeedFunc: func(device nvml.Device, n int) (int, nvml.Return) {
//				panic("mock out the DeviceGetTargetFanSpeed method")
//			},
//			DeviceGetTemperatureFunc: func(device nvml.Device, temperatureSensors nvml.TemperatureSensors) (uint32, nvml.Return) {
//				panic("mock out the DeviceGetTemperature method")
//			},
//			DeviceGetTemperatureThresholdFunc: func(device nvml.Device, temperatureThresholds nvml.TemperatureThresholds) (uint32, nvml.Return) {
//				panic("mock out the DeviceGetTemperatureThreshold method")
//			},
//			DeviceGetTemperatureVFunc: func(device nvml.Device) nvml.TemperatureHandler {
//				panic("mock out the DeviceGetTemperatureV method")
//			},
//			DeviceGetThermalSettingsFunc: func(device nvml.Device, v uint32) (nvml.GpuThermalSettings, nvml.Return) {
//				panic("mock out the DeviceGetThermalSettings method")
//			},
//			DeviceGetTopologyCommonAncestorFunc: func(device1 nvml.Device, device2 nvml.Device) (nvml.GpuTopologyLevel, nvml.Return) {
//				panic("mock out the DeviceGetTopologyCommonAncestor method")
//			},
//			DeviceGetTopologyNearestGpusFunc: func(device nvml.Device, gpuTopologyLevel nvml.GpuTopologyLevel) ([]nvml.Device, nvml.Return) {
//				panic("mock out the DeviceGetTopologyNearestGpus method")
//			},
//			DeviceGetTotalEccErrorsFunc: func(device nvml.Device, memoryErrorType nvml.MemoryErrorType, eccCounterType nvml.EccCounterType) (uint64, nvml.Return) {
//				panic("mock out the DeviceGetTotalEccErrors method")
//			},
//			DeviceGetTotalEnergyConsumptionFunc: func(device nvml.Device) (uint64, nvml.Return) {
//				panic("mock out the DeviceGetTotalEnergyConsumption method")
//			},
//			DeviceGetUUIDFunc: func(device nvml.Device) (string, nvml.Return) {
//				panic("mock out the DeviceGetUUID method")
//			},
//			DeviceGetUtilizationRatesFunc: func(device nvml.Device) (nvml.Utilization, nvml.Return) {
//				panic("mock out the DeviceGetUtilizationRates method")
//			},
//			DeviceGetVbiosVersionFunc: func(device nvml.Device) (string, nvml.Return) {
//				panic("mock out the DeviceGetVbiosVersion method")
//			},
//			DeviceGetVgpuCapabilitiesFunc: func(device nvml.Device, deviceVgpuCapability nvml.DeviceVgpuCapability) (bool, nvml.Return) {
//				panic("mock out the DeviceGetVgpuCapabilities method")
//			},
//			DeviceGetVgpuHeterogeneousModeFunc: func(device nvml.Device) (nvml.VgpuHeterogeneousMode, nvml.Return) {
//				panic("mock out the DeviceGetVgpuHeterogeneousMode method")
//			},
//			DeviceGetVgpuInstancesUtilizationInfoFunc: func(device nvml.Device) (nvml.VgpuInstancesUtilizationInfo, nvml.Return) {
//				panic("mock out the DeviceGetVgpuInstancesUtilizationInfo method")
//			},
//			DeviceGetVgpuMetadataFunc: func(device nvml.Device) (nvml.VgpuPgpuMetadata, nvml.Return) {
//				panic("mock out the DeviceGetVgpuMetadata method")
//			},
//			DeviceGetVgpuProcessUtilizationFunc: func(device nvml.Device, v uint64) ([]nvml.VgpuProcessUtilizationSample, nvml.Return) {
//				panic("mock out the DeviceGetVgpuProcessUtilization method")
//			},
//			DeviceGetVgpuProcessesUtilizationInfoFunc: func(device nvml.Device) (nvml.VgpuProcessesUtilizationInfo, nvml.Return) {
//				panic("mock out the DeviceGetVgpuProcessesUtilizationInfo method")
//			},
//			DeviceGetVgpuSchedulerCapabilitiesFunc: func(device nvml.Device) (nvml.VgpuSchedulerCapabilities, nvml.Return) {
//				panic("mock out the DeviceGetVgpuSchedulerCapabilities method")
//			},
//			DeviceGetVgpuSchedulerLogFunc: func(device nvml.Device) (nvml.VgpuSchedulerLog, nvml.Return) {
//				panic("mock out the DeviceGetVgpuSchedulerLog method")
//			},
//			DeviceGetVgpuSchedulerStateFunc: func(device nvml.Device) (nvml.VgpuSchedulerGetState, nvml.Return) {
//				panic("mock out the DeviceGetVgpuSchedulerState method")
//			},
//			DeviceGetVgpuTypeCreatablePlacementsFunc: func(device nvml.Device, vgpuTypeId nvml.VgpuTypeId) (nvml.VgpuPlacementList, nvml.Return) {
//				panic("mock out the DeviceGetVgpuTypeCreatablePlacements method")
//			},
//			DeviceGetVgpuTypeSupportedPlacementsFunc: func(device nvml.Device, vgpuTypeId nvml.VgpuTypeId) (nvml.VgpuPlacementList, nvml.Return) {
//				panic("mock out the DeviceGetVgpuTypeSupportedPlacements method")
//			},
//			DeviceGetVgpuUtilizationFunc: func(device nvml.Device, v uint64) (nvml.ValueType, []nvml.VgpuInstanceUtilizationSample, nvml.Return) {
//				panic("mock out the DeviceGetVgpuUtilization method")
//			},
//			DeviceGetViolationStatusFunc: func(device nvml.Device, perfPolicyType nvml.PerfPolicyType) (nvml.ViolationTime, nvml.Return) {
//				panic("mock out the DeviceGetViolationStatus method")
//			},
//			DeviceGetVirtualizationModeFunc: func(device nvml.Device) (nvml.GpuVirtualizationMode, nvml.Return) {
//				panic("mock out the DeviceGetVirtualizationMode method")
//			},
//			DeviceIsMigDeviceHandleFunc: func(device nvml.Device) (bool, nvml.Return) {
//				panic("mock out the DeviceIsMigDeviceHandle method")
//			},
//			DeviceModifyDrainStateFunc: func(pciInfo *nvml.PciInfo, enableState nvml.EnableState) nvml.Return {
//				panic("mock out the DeviceModifyDrainState method")
//			},
//			DeviceOnSameBoardFunc: func(device1 nvml.Device, device2 nvml.Device) (int, nvml.Return) {
//				panic("mock out the DeviceOnSameBoard method")
//			},
//			DevicePowerSmoothingActivatePresetProfileFunc: func(device nvml.Device, powerSmoothingProfile *nvml.PowerSmoothingProfile) nvml.Return {
//				panic("mock out the DevicePowerSmoothingActivatePresetProfile method")
//			},
//			DevicePowerSmoothingSetStateFunc: func(device nvml.Device, powerSmoothingState *nvml.PowerSmoothingState) nvml.Return {
//				panic("mock out the DevicePowerSmoothingSetState method")
//			},
//			DevicePowerSmoothingUpdatePresetProfileParamFunc: func(device nvml.Device, powerSmoothingProfile *nvml.PowerSmoothingProfile) nvml.Return {
//				panic("mock out the DevicePowerSmoothingUpdatePresetProfileParam method")
//			},
//			DeviceQueryDrainStateFunc: func(pciInfo *nvml.PciInfo) (nvml.EnableState, nvml.Return) {
//				panic("mock out the DeviceQueryDrainState method")
//			},
//			DeviceReadWritePRM_v1Func: func(device nvml.Device, pRMTLV_v1 *nvml.PRMTLV_v1) nvml.Return {
//				panic("mock out the DeviceReadWritePRM_v1 method")
//			},
//			DeviceRegisterEventsFunc: func(device nvml.Device, v uint64, eventSet nvml.EventSet) nvml.Return {
//				panic("mock out the DeviceRegisterEvents method")
//			},
//			DeviceRemoveGpuFunc: func(pciInfo *nvml.PciInfo) nvml.Return {
//				panic("mock out the DeviceRemoveGpu method")
//			},
//			DeviceRemoveGpu_v2Func: func(pciInfo *nvml.PciInfo, detachGpuState nvml.DetachGpuState, pcieLinkState nvml.PcieLinkState) nvml.Return {
//				panic("mock out the DeviceRemoveGpu_v2 method")
//			},
//			DeviceResetApplicationsClocksFunc: func(device nvml.Device) nvml.Return {
//				panic("mock out the DeviceResetApplicationsClocks method")
//			},
//			DeviceResetGpuLockedClocksFunc: func(device nvml.Device) nvml.Return {
//				panic("mock out the DeviceResetGpuLockedClocks method")
//			},
//			DeviceResetMemoryLockedClocksFunc: func(device nvml.Device) nvml.Return {
//				panic("mock out the DeviceResetMemoryLockedClocks method")
//			},
//			DeviceResetNvLinkErrorCountersFunc: func(device nvml.Device, n int) nvml.Return {
//				panic("mock out the DeviceResetNvLinkErrorCounters method")
//			},
//			DeviceResetNvLinkUtilizationCounterFunc: func(device nvml.Device, n1 int, n2 int) nvml.Return {
//				panic("mock out the DeviceResetNvLinkUtilizationCounter method")
//			},
//			DeviceSetAPIRestrictionFunc: func(device nvml.Device, restrictedAPI nvml.RestrictedAPI, enableState nvml.EnableState) nvml.Return {
//				panic("mock out the DeviceSetAPIRestriction method")
//			},
//			DeviceSetAccountingModeFunc: func(device nvml.Device, enableState nvml.EnableState) nvml.Return {
//				panic("mock out the DeviceSetAccountingMode method")
//			},
//			DeviceSetApplicationsClocksFunc: func(device nvml.Device, v1 uint32, v2 uint32) nvml.Return {
//				panic("mock out the DeviceSetApplicationsClocks method")
//			},
//			DeviceSetAutoBoostedClocksEnabledFunc: func(device nvml.Device, enableState nvml.EnableState) nvml.Return {
//				panic("mock out the DeviceSetAutoBoostedClocksEnabled method")
//			},
//			DeviceSetClockOffsetsFunc: func(device nvml.Device, clockOffset nvml.ClockOffset) nvml.Return {
//				panic("mock out the DeviceSetClockOffsets method")
//			},
//			DeviceSetComputeModeFunc: func(device nvml.Device, computeMode nvml.ComputeMode) nvml.Return {
//				panic("mock out the DeviceSetComputeMode method")
//			},
//			DeviceSetConfComputeUnprotectedMemSizeFunc: func(device nvml.Device, v uint64) nvml.Return {
//				panic("mock out the DeviceSetConfComputeUnprotectedMemSize method")
//			},
//			DeviceSetCpuAffinityFunc: func(device nvml.Device) nvml.Return {
//				panic("mock out the DeviceSetCpuAffinity method")
//			},
//			DeviceSetDefaultAutoBoostedClocksEnabledFunc: func(device nvml.Device, enableState nvml.EnableState, v uint32) nvml.Return {
//				panic("mock out the DeviceSetDefaultAutoBoostedClocksEnabled method")
//			},
//			DeviceSetDefaultFanSpeed_v2Func: func(device nvml.Device, n int) nvml.Return {
//				panic("mock out the DeviceSetDefaultFanSpeed_v2 method")
//			},
//			DeviceSetDramEncryptionModeFunc: func(device nvml.Device, dramEncryptionInfo *nvml.DramEncryptionInfo) nvml.Return {
//				panic("mock out the DeviceSetDramEncryptionMode method")
//			},
//			DeviceSetDriverModelFunc: func(device nvml.Device, driverModel nvml.DriverModel, v uint32) nvml.Return {
//				panic("mock out the DeviceSetDriverModel method")
//			},
//			DeviceSetEccModeFunc: func(device nvml.Device, enableState nvml.EnableState) nvml.Return {
//				panic("mock out the DeviceSetEccMode method")
//			},
//			DeviceSetFanControlPolicyFunc: func(device nvml.Device, n int, fanControlPolicy nvml.FanControlPolicy) nvml.Return {
//				panic("mock out the DeviceSetFanControlPolicy method")
//			},
//			DeviceSetFanSpeed_v2Func: func(device nvml.Device, n1 int, n2 int) nvml.Return {
//				panic("mock out the DeviceSetFanSpeed_v2 method")
//			},
//			DeviceSetGpcClkVfOffsetFunc: func(device nvml.Device, n int) nvml.Return {
//				panic("mock out the DeviceSetGpcClkVfOffset method")
//			},
//			DeviceSetGpuLockedClocksFunc: func(device nvml.Device, v1 uint32, v2 uint32) nvml.Return {
//				panic("mock out the DeviceSetGpuLockedClocks method")
//			},
//			DeviceSetGpuOperationModeFunc: func(device nvml.Device, gpuOperationMode nvml.GpuOperationMode) nvml.Return {
//				panic("mock out the DeviceSetGpuOperationMode method")
//			},
//			DeviceSetMemClkVfOffsetFunc: func(device nvml.Device, n int) nvml.Return {
//				panic("mock out the DeviceSetMemClkVfOffset method")
//			},
//			DeviceSetMemoryLockedClocksFunc: func(device nvml.Device, v1 uint32, v2 uint32) nvml.Return {
//				panic("mock out the DeviceSetMemoryLockedClocks method")
//			},
//			DeviceSetMigModeFunc: func(device nvml.Device, n int) (nvml.Return, nvml.Return) {
//				panic("mock out the DeviceSetMigMode method")
//			},
//			DeviceSetNvLinkDeviceLowPowerThresholdFunc: func(device nvml.Device, nvLinkPowerThres *nvml.NvLinkPowerThres) nvml.Return {
//				panic("mock out the DeviceSetNvLinkDeviceLowPowerThreshold method")
//			},
//			DeviceSetNvLinkUtilizationControlFunc: func(device nvml.Device, n1 int, n2 int, nvLinkUtilizationControl *nvml.NvLinkUtilizationControl, b bool) nvml.Return {
//				panic("mock out the DeviceSetNvLinkUtilizationControl method")
//			},
//			DeviceSetNvlinkBwModeFunc: func(device nvml.Device, nvlinkSetBwMode *nvml.NvlinkSetBwMode) nvml.Return {
//				panic("mock out the DeviceSetNvlinkBwMode method")
//			},
//			DeviceSetPersistenceModeFunc: func(device nvml.Device, enableState nvml.EnableState) nvml.Return {
//				panic("mock out the DeviceSetPersistenceMode method")
//			},
//			DeviceSetPowerManagementLimitFunc: func(device nvml.Device, v uint32) nvml.Return {
//				panic("mock out the DeviceSetPowerManagementLimit method")
//			},
//			DeviceSetPowerManagementLimit_v2Func: func(device nvml.Device, powerValue_v2 *nvml.PowerValue_v2) nvml.Return {
//				panic("mock out the DeviceSetPowerManagementLimit_v2 method")
//			},
//			DeviceSetTemperatureThresholdFunc: func(device nvml.Device, temperatureThresholds nvml.TemperatureThresholds, n int) nvml.Return {
//				panic("mock out the DeviceSetTemperatureThreshold method")
//			},
//			DeviceSetVgpuCapabilitiesFunc: func(device nvml.Device, deviceVgpuCapability nvml.DeviceVgpuCapability, enableState nvml.EnableState) nvml.Return {
//				panic("mock out the DeviceSetVgpuCapabilities method")
//			},
//			DeviceSetVgpuHeterogeneousModeFunc: func(device nvml.Device, vgpuHeterogeneousMode nvml.VgpuHeterogeneousMode) nvml.Return {
//				panic("mock out the DeviceSetVgpuHeterogeneousMode method")
//			},
//			DeviceSetVgpuSchedulerStateFunc: func(device nvml.Device, vgpuSchedulerSetState *nvml.VgpuSchedulerSetState) nvml.Return {
//				panic("mock out the DeviceSetVgpuSchedulerState method")
//			},
//			DeviceSetVirtualizationModeFunc: func(device nvml.Device, gpuVirtualizationMode nvml.GpuVirtualizationMode) nvml.Return {
//				panic("mock out the DeviceSetVirtualizationMode method")
//			},
//			DeviceValidateInforomFunc: func(device nvml.Device) nvml.Return {
//				panic("mock out the DeviceValidateInforom method")
//			},
//			DeviceWorkloadPowerProfileClearRequestedProfilesFunc: func(device nvml.Device, workloadPowerProfileRequestedProfiles *nvml.WorkloadPowerProfileRequestedProfiles) nvml.Return {
//				panic("mock out the DeviceWorkloadPowerProfileClearRequestedProfiles method")
//			},
//			DeviceWorkloadPowerProfileGetCurrentProfilesFunc: func(device nvml.Device) (nvml.WorkloadPowerProfileCurrentProfiles, nvml.Return) {
//				panic("mock out the DeviceWorkloadPowerProfileGetCurrentProfiles method")
//			},
//			DeviceWorkloadPowerProfileGetProfilesInfoFunc: func(device nvml.Device) (nvml.WorkloadPowerProfileProfilesInfo, nvml.Return) {
//				panic("mock out the DeviceWorkloadPowerProfileGetProfilesInfo method")
//			},
//			DeviceWorkloadPowerProfileSetRequestedProfilesFunc: func(device nvml.Device, workloadPowerProfileRequestedProfiles *nvml.WorkloadPowerProfileRequestedProfiles) nvml.Return {
//				panic("mock out the DeviceWorkloadPowerProfileSetRequestedProfiles method")
//			},
//			ErrorStringFunc: func(returnMoqParam nvml.Return) string {
//				panic("mock out the ErrorString method")
//			},
//			EventSetCreateFunc: func() (nvml.EventSet, nvml.Return) {
//				panic("mock out the EventSetCreate method")
//			},
//			EventSetFreeFunc: func(eventSet nvml.EventSet) nvml.Return {
//				panic("mock out the EventSetFree method")
//			},
//			EventSetWaitFunc: func(eventSet nvml.EventSet, v uint32) (nvml.EventData, nvml.Return) {
//				panic("mock out the EventSetWait method")
//			},
//			ExtensionsFunc: func() nvml.ExtendedInterface {
//				panic("mock out the Extensions method")
//			},
//			GetExcludedDeviceCountFunc: func() (int, nvml.Return) {
//				panic("mock out the GetExcludedDeviceCount method")
//			},
//			GetExcludedDeviceInfoByIndexFunc: func(n int) (nvml.ExcludedDeviceInfo, nvml.Return) {
//				panic("mock out the GetExcludedDeviceInfoByIndex method")
//			},
//			GetVgpuCompatibilityFunc: func(vgpuMetadata *nvml.VgpuMetadata, vgpuPgpuMetadata *nvml.VgpuPgpuMetadata) (nvml.VgpuPgpuCompatibility, nvml.Return) {
//				panic("mock out the GetVgpuCompatibility method")
//			},
//			GetVgpuDriverCapabilitiesFunc: func(vgpuDriverCapability nvml.VgpuDriverCapability) (bool, nvml.Return) {
//				panic("mock out the GetVgpuDriverCapabilities method")
//			},
//			GetVgpuVersionFunc: func() (nvml.VgpuVersion, nvml.VgpuVersion, nvml.Return) {
//				panic("mock out the GetVgpuVersion method")
//			},
//			GpmMetricsGetFunc: func(gpmMetricsGetType *nvml.GpmMetricsGetType) nvml.Return {
//				panic("mock out the GpmMetricsGet method")
//			},
//			GpmMetricsGetVFunc: func(gpmMetricsGetType *nvml.GpmMetricsGetType) nvml.GpmMetricsGetVType {
//				panic("mock out the GpmMetricsGetV method")
//			},
//			GpmMigSampleGetFunc: func(device nvml.Device, n int, gpmSample nvml.GpmSample) nvml.Return {
//				panic("mock out the GpmMigSampleGet method")
//			},
//			GpmQueryDeviceSupportFunc: func(device nvml.Device) (nvml.GpmSupport, nvml.Return) {
//				panic("mock out the GpmQueryDeviceSupport method")
//			},
//			GpmQueryDeviceSupportVFunc: func(device nvml.Device) nvml.GpmSupportV {
//				panic("mock out the GpmQueryDeviceSupportV method")
//			},
//			GpmQueryIfStreamingEnabledFunc: func(device nvml.Device) (uint32, nvml.Return) {
//				panic("mock out the GpmQueryIfStreamingEnabled method")
//			},
//			GpmSampleAllocFunc: func() (nvml.GpmSample, nvml.Return) {
//				panic("mock out the GpmSampleAlloc method")
//			},
//			GpmSampleFreeFunc: func(gpmSample nvml.GpmSample) nvml.Return {
//				panic("mock out the GpmSampleFree method")
//			},
//			GpmSampleGetFunc: func(device nvml.Device, gpmSample nvml.GpmSample) nvml.Return {
//				panic("mock out the GpmSampleGet method")
//			},
//			GpmSetStreamingEnabledFunc: func(device nvml.Device, v uint32) nvml.Return {
//				panic("mock out the GpmSetStreamingEnabled method")
//			},
//			GpuInstanceCreateComputeInstanceFunc: func(gpuInstance nvml.GpuInstance, computeInstanceProfileInfo *nvml.ComputeInstanceProfileInfo) (nvml.ComputeInstance, nvml.Return) {
//				panic("mock out the GpuInstanceCreateComputeInstance method")
//			},
//			GpuInstanceCreateComputeInstanceWithPlacementFunc: func(gpuInstance nvml.GpuInstance, computeInstanceProfileInfo *nvml.ComputeInstanceProfileInfo, computeInstancePlacement *nvml.ComputeInstancePlacement) (nvml.ComputeInstance, nvml.Return) {
//				panic("mock out the GpuInstanceCreateComputeInstanceWithPlacement method")
//			},
//			GpuInstanceDestroyFunc: func(gpuInstance nvml.GpuInstance) nvml.Return {
//				panic("mock out the GpuInstanceDestroy method")
//			},
//			GpuInstanceGetActiveVgpusFunc: func(gpuInstance nvml.GpuInstance) (nvml.ActiveVgpuInstanceInfo, nvml.Return) {
//				panic("mock out the GpuInstanceGetActiveVgpus method")
//			},
//			GpuInstanceGetComputeInstanceByIdFunc: func(gpuInstance nvml.GpuInstance, n int) (nvml.ComputeInstance, nvml.Return) {
//				panic("mock out the GpuInstanceGetComputeInstanceById method")
//			},
//			GpuInstanceGetComputeInstancePossiblePlacementsFunc: func(gpuInstance nvml.GpuInstance, computeInstanceProfileInfo *nvml.ComputeInstanceProfileInfo) ([]nvml.ComputeInstancePlacement, nvml.Return) {
//				panic("mock out the GpuInstanceGetComputeInstancePossiblePlacements method")
//			},
//			GpuInstanceGetComputeInstanceProfileInfoFunc: func(gpuInstance nvml.GpuInstance, n1 int, n2 int) (nvml.ComputeInstanceProfileInfo, nvml.Return) {
//				panic("mock out the GpuInstanceGetComputeInstanceProfileInfo method")
//			},
//			GpuInstanceGetComputeInstanceProfileInfoVFunc: func(gpuInstance nvml.GpuInstance, n1 int, n2 int) nvml.ComputeInstanceProfileInfoHandler {
//				panic("mock out the GpuInstanceGetComputeInstanceProfileInfoV method")
//			},
//			GpuInstanceGetComputeInstanceRemainingCapacityFunc: func(gpuInstance nvml.GpuInstance, computeInstanceProfileInfo *nvml.ComputeInstanceProfileInfo) (int, nvml.Return) {
//				panic("mock out the GpuInstanceGetComputeInstanceRemainingCapacity method")
//			},
//			GpuInstanceGetComputeInstancesFunc: func(gpuInstance nvml.GpuInstance, computeInstanceProfileInfo *nvml.ComputeInstanceProfileInfo) ([]nvml.ComputeInstance, nvml.Return) {
//				panic("mock out the GpuInstanceGetComputeInstances method")
//			},
//			GpuInstanceGetCreatableVgpusFunc: func(gpuInstance nvml.GpuInstance) (nvml.VgpuTypeIdInfo, nvml.Return) {
//				panic("mock out the GpuInstanceGetCreatableVgpus method")
//			},
//			GpuInstanceGetInfoFunc: func(gpuInstance nvml.GpuInstance) (nvml.GpuInstanceInfo, nvml.Return) {
//				panic("mock out the GpuInstanceGetInfo method")
//			},
//			GpuInstanceGetVgpuHeterogeneousModeFunc: func(gpuInstance nvml.GpuInstance) (nvml.VgpuHeterogeneousMode, nvml.Return) {
//				panic("mock out the GpuInstanceGetVgpuHeterogeneousMode method")
//			},
//			GpuInstanceGetVgpuSchedulerLogFunc: func(gpuInstance nvml.GpuInstance) (nvml.VgpuSchedulerLogInfo, nvml.Return) {
//				panic("mock out the GpuInstanceGetVgpuSchedulerLog method")
//			},
//			GpuInstanceGetVgpuSchedulerStateFunc: func(gpuInstance nvml.GpuInstance) (nvml.VgpuSchedulerStateInfo, nvml.Return) {
//				panic("mock out the GpuInstanceGetVgpuSchedulerState method")
//			},
//			GpuInstanceGetVgpuTypeCreatablePlacementsFunc: func(gpuInstance nvml.GpuInstance) (nvml.VgpuCreatablePlacementInfo, nvml.Return) {
//				panic("mock out the GpuInstanceGetVgpuTypeCreatablePlacements method")
//			},
//			GpuInstanceSetVgpuHeterogeneousModeFunc: func(gpuInstance nvml.GpuInstance, vgpuHeterogeneousMode *nvml.VgpuHeterogeneousMode) nvml.Return {
//				panic("mock out the GpuInstanceSetVgpuHeterogeneousMode method")
//			},
//			GpuInstanceSetVgpuSchedulerStateFunc: func(gpuInstance nvml.GpuInstance, vgpuSchedulerState *nvml.VgpuSchedulerState) nvml.Return {
//				panic("mock out the GpuInstanceSetVgpuSchedulerState method")
//			},
//			InitFunc: func() nvml.Return {
//				panic("mock out the Init method")
//			},
//			InitWithFlagsFunc: func(v uint32) nvml.Return {
//				panic("mock out the InitWithFlags method")
//			},
//			SetVgpuVersionFunc: func(vgpuVersion *nvml.VgpuVersion) nvml.Return {
//				panic("mock out the SetVgpuVersion method")
//			},
//			ShutdownFunc: func() nvml.Return {
//				panic("mock out the Shutdown method")
//			},
//			SystemEventSetCreateFunc: func(systemEventSetCreateRequest *nvml.SystemEventSetCreateRequest) nvml.Return {
//				panic("mock out the SystemEventSetCreate method")
//			},
//			SystemEventSetFreeFunc: func(systemEventSetFreeRequest *nvml.SystemEventSetFreeRequest) nvml.Return {
//				panic("mock out the SystemEventSetFree method")
//			},
//			SystemEventSetWaitFunc: func(systemEventSetWaitRequest *nvml.SystemEventSetWaitRequest) nvml.Return {
//				panic("mock out the SystemEventSetWait method")
//			},
//			SystemGetConfComputeCapabilitiesFunc: func() (nvml.ConfComputeSystemCaps, nvml.Return) {
//				panic("mock out the SystemGetConfComputeCapabilities method")
//			},
//			SystemGetConfComputeGpusReadyStateFunc: func() (uint32, nvml.Return) {
//				panic("mock out the SystemGetConfComputeGpusReadyState method")
//			},
//			SystemGetConfComputeKeyRotationThresholdInfoFunc: func() (nvml.ConfComputeGetKeyRotationThresholdInfo, nvml.Return) {
//				panic("mock out the SystemGetConfComputeKeyRotationThresholdInfo method")
//			},
//			SystemGetConfComputeSettingsFunc: func() (nvml.SystemConfComputeSettings, nvml.Return) {
//				panic("mock out the SystemGetConfComputeSettings method")
//			},
//			SystemGetConfComputeStateFunc: func() (nvml.ConfComputeSystemState, nvml.Return) {
//				panic("mock out the SystemGetConfComputeState method")
//			},
//			SystemGetCudaDriverVersionFunc: func() (int, nvml.Return) {
//				panic("mock out the SystemGetCudaDriverVersion method")
//			},
//			SystemGetCudaDriverVersion_v2Func: func() (int, nvml.Return) {
//				panic("mock out the SystemGetCudaDriverVersion_v2 method")
//			},
//			SystemGetDriverBranchFunc: func() (nvml.SystemDriverBranchInfo, nvml.Return) {
//				panic("mock out the SystemGetDriverBranch method")
//			},
//			SystemGetDriverVersionFunc: func() (string, nvml.Return) {
//				panic("mock out the SystemGetDriverVersion method")
//			},
//			SystemGetHicVersionFunc: func() ([]nvml.HwbcEntry, nvml.Return) {
//				panic("mock out the SystemGetHicVersion method")
//			},
//			SystemGetNVMLVersionFunc: func() (string, nvml.Return) {
//				panic("mock out the SystemGetNVMLVersion method")
//			},
//			SystemGetNvlinkBwModeFunc: func() (uint32, nvml.Return) {
//				panic("mock out the SystemGetNvlinkBwMode method")
//			},
//			SystemGetProcessNameFunc: func(n int) (string, nvml.Return) {
//				panic("mock out the SystemGetProcessName method")
//			},
//			SystemGetTopologyGpuSetFunc: func(n int) ([]nvml.Device, nvml.Return) {
//				panic("mock out the SystemGetTopologyGpuSet method")
//			},
//			SystemRegisterEventsFunc: func(systemRegisterEventRequest *nvml.SystemRegisterEventRequest) nvml.Return {
//				panic("mock out the SystemRegisterEvents method")
//			},
//			SystemSetConfComputeGpusReadyStateFunc: func(v uint32) nvml.Return {
//				panic("mock out the SystemSetConfComputeGpusReadyState method")
//			},
//			SystemSetConfComputeKeyRotationThresholdInfoFunc: func(confComputeSetKeyRotationThresholdInfo nvml.ConfComputeSetKeyRotationThresholdInfo) nvml.Return {
//				panic("mock out the SystemSetConfComputeKeyRotationThresholdInfo method")
//			},
//			SystemSetNvlinkBwModeFunc: func(v uint32) nvml.Return {
//				panic("mock out the SystemSetNvlinkBwMode method")
//			},
//			UnitGetCountFunc: func() (int, nvml.Return) {
//				panic("mock out the UnitGetCount method")
//			},
//			UnitGetDevicesFunc: func(unit nvml.Unit) ([]nvml.Device, nvml.Return) {
//				panic("mock out the UnitGetDevices method")
//			},
//			UnitGetFanSpeedInfoFunc: func(unit nvml.Unit) (nvml.UnitFanSpeeds, nvml.Return) {
//				panic("mock out the UnitGetFanSpeedInfo method")
//			},
//			UnitGetHandleByIndexFunc: func(n int) (nvml.Unit, nvml.Return) {
//				panic("mock out the UnitGetHandleByIndex method")
//			},
//			UnitGetLedStateFunc: func(unit nvml.Unit) (nvml.LedState, nvml.Return) {
//				panic("mock out the UnitGetLedState method")
//			},
//			UnitGetPsuInfoFunc: func(unit nvml.Unit) (nvml.PSUInfo, nvml.Return) {
//				panic("mock out the UnitGetPsuInfo method")
//			},
//			UnitGetTemperatureFunc: func(unit nvml.Unit, n int) (uint32, nvml.Return) {
//				panic("mock out the UnitGetTemperature method")
//			},
//			UnitGetUnitInfoFunc: func(unit nvml.Unit) (nvml.UnitInfo, nvml.Return) {
//				panic("mock out the UnitGetUnitInfo method")
//			},
//			UnitSetLedStateFunc: func(unit nvml.Unit, ledColor nvml.LedColor) nvml.Return {
//				panic("mock out the UnitSetLedState method")
//			},
//			VgpuInstanceClearAccountingPidsFunc: func(vgpuInstance nvml.VgpuInstance) nvml.Return {
//				panic("mock out the VgpuInstanceClearAccountingPids method")
//			},
//			VgpuInstanceGetAccountingModeFunc: func(vgpuInstance nvml.VgpuInstance) (nvml.EnableState, nvml.Return) {
//				panic("mock out the VgpuInstanceGetAccountingMode method")
//			},
//			VgpuInstanceGetAccountingPidsFunc: func(vgpuInstance nvml.VgpuInstance) ([]int, nvml.Return) {
//				panic("mock out the VgpuInstanceGetAccountingPids method")
//			},
//			VgpuInstanceGetAccountingStatsFunc: func(vgpuInstance nvml.VgpuInstance, n int) (nvml.AccountingStats, nvml.Return) {
//				panic("mock out the VgpuInstanceGetAccountingStats method")
//			},
//			VgpuInstanceGetEccModeFunc: func(vgpuInstance nvml.VgpuInstance) (nvml.EnableState, nvml.Return) {
//				panic("mock out the VgpuInstanceGetEccMode method")
//			},
//			VgpuInstanceGetEncoderCapacityFunc: func(vgpuInstance nvml.VgpuInstance) (int, nvml.Return) {
//				panic("mock out the VgpuInstanceGetEncoderCapacity method")
//			},
//			VgpuInstanceGetEncoderSessionsFunc: func(vgpuInstance nvml.VgpuInstance) (int, nvml.EncoderSessionInfo, nvml.Return) {
//				panic("mock out the VgpuInstanceGetEncoderSessions method")
//			},
//			VgpuInstanceGetEncoderStatsFunc: func(vgpuInstance nvml.VgpuInstance) (int, uint32, uint32, nvml.Return) {
//				panic("mock out the VgpuInstanceGetEncoderStats method")
//			},
//			VgpuInstanceGetFBCSessionsFunc: func(vgpuInstance nvml.VgpuInstance) (int, nvml.FBCSessionInfo, nvml.Return) {
//				panic("mock out the VgpuInstanceGetFBCSessions method")
//			},
//			VgpuInstanceGetFBCStatsFunc: func(vgpuInstance nvml.VgpuInstance) (nvml.FBCStats, nvml.Return) {
//				panic("mock out the VgpuInstanceGetFBCStats method")
//			},
//			VgpuInstanceGetFbUsageFunc: func(vgpuInstance nvml.VgpuInstance) (uint64, nvml.Return) {
//				panic("mock out the VgpuInstanceGetFbUsage method")
//			},
//			VgpuInstanceGetFrameRateLimitFunc: func(vgpuInstance nvml.VgpuInstance) (uint32, nvml.Return) {
//				panic("mock out the VgpuInstanceGetFrameRateLimit method")
//			},
//			VgpuInstanceGetGpuInstanceIdFunc: func(vgpuInstance nvml.VgpuInstance) (int, nvml.Return) {
//				panic("mock out the VgpuInstanceGetGpuInstanceId method")
//			},
//			VgpuInstanceGetGpuPciIdFunc: func(vgpuInstance nvml.VgpuInstance) (string, nvml.Return) {
//				panic("mock out the VgpuInstanceGetGpuPciId method")
//			},
//			VgpuInstanceGetLicenseInfoFunc: func(vgpuInstance nvml.VgpuInstance) (nvml.VgpuLicenseInfo, nvml.Return) {
//				panic("mock out the VgpuInstanceGetLicenseInfo method")
//			},
//			VgpuInstanceGetLicenseStatusFunc: func(vgpuInstance nvml.VgpuInstance) (int, nvml.Return) {
//				panic("mock out the VgpuInstanceGetLicenseStatus method")
//			},
//			VgpuInstanceGetMdevUUIDFunc: func(vgpuInstance nvml.VgpuInstance) (string, nvml.Return) {
//				panic("mock out the VgpuInstanceGetMdevUUID method")
//			},
//			VgpuInstanceGetMetadataFunc: func(vgpuInstance nvml.VgpuInstance) (nvml.VgpuMetadata, nvml.Return) {
//				panic("mock out the VgpuInstanceGetMetadata method")
//			},
//			VgpuInstanceGetRuntimeStateSizeFunc: func(vgpuInstance nvml.VgpuInstance) (nvml.VgpuRuntimeState, nvml.Return) {
//				panic("mock out the VgpuInstanceGetRuntimeStateSize method")
//			},
//			VgpuInstanceGetTypeFunc: func(vgpuInstance nvml.VgpuInstance) (nvml.VgpuTypeId, nvml.Return) {
//				panic("mock out the VgpuInstanceGetType method")
//			},
//			VgpuInstanceGetUUIDFunc: func(vgpuInstance nvml.VgpuInstance) (string, nvml.Return) {
//				panic("mock out the VgpuInstanceGetUUID method")
//			},
//			VgpuInstanceGetVmDriverVersionFunc: func(vgpuInstance nvml.VgpuInstance) (string, nvml.Return) {
//				panic("mock out the VgpuInstanceGetVmDriverVersion method")
//			},
//			VgpuInstanceGetVmIDFunc: func(vgpuInstance nvml.VgpuInstance) (string, nvml.VgpuVmIdType, nvml.Return) {
//				panic("mock out the VgpuInstanceGetVmID method")
//			},
//			VgpuInstanceSetEncoderCapacityFunc: func(vgpuInstance nvml.VgpuInstance, n int) nvml.Return {
//				panic("mock out the VgpuInstanceSetEncoderCapacity method")
//			},
//			VgpuTypeGetBAR1InfoFunc: func(vgpuTypeId nvml.VgpuTypeId) (nvml.VgpuTypeBar1Info, nvml.Return) {
//				panic("mock out the VgpuTypeGetBAR1Info method")
//			},
//			VgpuTypeGetCapabilitiesFunc: func(vgpuTypeId nvml.VgpuTypeId, vgpuCapability nvml.VgpuCapability) (bool, nvml.Return) {
//				panic("mock out the VgpuTypeGetCapabilities method")
//			},
//			VgpuTypeGetClassFunc: func(vgpuTypeId nvml.VgpuTypeId) (string, nvml.Return) {
//				panic("mock out the VgpuTypeGetClass method")
//			},
//			VgpuTypeGetDeviceIDFunc: func(vgpuTypeId nvml.VgpuTypeId) (uint64, uint64, nvml.Return) {
//				panic("mock out the VgpuTypeGetDeviceID method")
//			},
//			VgpuTypeGetFrameRateLimitFunc: func(vgpuTypeId nvml.VgpuTypeId) (uint32, nvml.Return) {
//				panic("mock out the VgpuTypeGetFrameRateLimit method")
//			},
//			VgpuTypeGetFramebufferSizeFunc: func(vgpuTypeId nvml.VgpuTypeId) (uint64, nvml.Return) {
//				panic("mock out the VgpuTypeGetFramebufferSize method")
//			},
//			VgpuTypeGetGpuInstanceProfileIdFunc: func(vgpuTypeId nvml.VgpuTypeId) (uint32, nvml.Return) {
//				panic("mock out the VgpuTypeGetGpuInstanceProfileId method")
//			},
//			VgpuTypeGetLicenseFunc: func(vgpuTypeId nvml.VgpuTypeId) (string, nvml.Return) {
//				panic("mock out the VgpuTypeGetLicense method")
//			},
//			VgpuTypeGetMaxInstancesFunc: func(device nvml.Device, vgpuTypeId nvml.VgpuTypeId) (int, nvml.Return) {
//				panic("mock out the VgpuTypeGetMaxInstances method")
//			},
//			VgpuTypeGetMaxInstancesPerGpuInstanceFunc: func(vgpuTypeMaxInstance *nvml.VgpuTypeMaxInstance) nvml.Return {
//				panic("mock out the VgpuTypeGetMaxInstancesPerGpuInstance method")
//			},
//			VgpuTypeGetMaxInstancesPerVmFunc: func(vgpuTypeId nvml.VgpuTypeId) (int, nvml.Return) {
//				panic("mock out the VgpuTypeGetMaxInstancesPerVm method")
//			},
//			VgpuTypeGetNameFunc: func(vgpuTypeId nvml.VgpuTypeId) (string, nvml.Return) {
//				panic("mock out the VgpuTypeGetName method")
//			},
//			VgpuTypeGetNumDisplayHeadsFunc: func(vgpuTypeId nvml.VgpuTypeId) (int, nvml.Return) {
//				panic("mock out the VgpuTypeGetNumDisplayHeads method")
//			},
//			VgpuTypeGetResolutionFunc: func(vgpuTypeId nvml.VgpuTypeId, n int) (uint32, uint32, nvml.Return) {
//				panic("mock out the VgpuTypeGetResolution method")
//			},
//		}
//
//		// use mockedInterface in code that requires nvml.Interface
//		// and then make assertions.
//
//	}
type Interface struct {
	// ComputeInstanceDestroyFunc mocks the ComputeInstanceDestroy method.
	ComputeInstanceDestroyFunc func(computeInstance nvml.ComputeInstance) nvml.Return

	// ComputeInstanceGetInfoFunc mocks the ComputeInstanceGetInfo method.
	ComputeInstanceGetInfoFunc func(computeInstance nvml.ComputeInstance) (nvml.ComputeInstanceInfo, nvml.Return)

	// DeviceClearAccountingPidsFunc mocks the DeviceClearAccountingPids method.
	DeviceClearAccountingPidsFunc func(device nvml.Device) nvml.Return

	// DeviceClearCpuAffinityFunc mocks the DeviceClearCpuAffinity method.
	DeviceClearCpuAffinityFunc func(device nvml.Device) nvml.Return

	// DeviceClearEccErrorCountsFunc mocks the DeviceClearEccErrorCounts method.
	DeviceClearEccErrorCountsFunc func(device nvml.Device, eccCounterType nvml.EccCounterType) nvml.Return

	// DeviceClearFieldValuesFunc mocks the DeviceClearFieldValues method.
	DeviceClearFieldValuesFunc func(device nvml.Device, fieldValues []nvml.FieldValue) nvml.Return

	// DeviceCreateGpuInstanceFunc mocks the DeviceCreateGpuInstance method.
	DeviceCreateGpuInstanceFunc func(device nvml.Device, gpuInstanceProfileInfo *nvml.GpuInstanceProfileInfo) (nvml.GpuInstance, nvml.Return)

	// DeviceCreateGpuInstanceWithPlacementFunc mocks the DeviceCreateGpuInstanceWithPlacement method.
	DeviceCreateGpuInstanceWithPlacementFunc func(device nvml.Device, gpuInstanceProfileInfo *nvml.GpuInstanceProfileInfo, gpuInstancePlacement *nvml.GpuInstancePlacement) (nvml.GpuInstance, nvml.Return)

	// DeviceDiscoverGpusFunc mocks the DeviceDiscoverGpus method.
	DeviceDiscoverGpusFunc func() (nvml.PciInfo, nvml.Return)

	// DeviceFreezeNvLinkUtilizationCounterFunc mocks the DeviceFreezeNvLinkUtilizationCounter method.
	DeviceFreezeNvLinkUtilizationCounterFunc func(device nvml.Device, n1 int, n2 int, enableState nvml.EnableState) nvml.Return

	// DeviceGetAPIRestrictionFunc mocks the DeviceGetAPIRestriction method.
	DeviceGetAPIRestrictionFunc func(device nvml.Device, restrictedAPI nvml.RestrictedAPI) (nvml.EnableState, nvml.Return)

	// DeviceGetAccountingBufferSizeFunc mocks the DeviceGetAccountingBufferSize method.
	DeviceGetAccountingBufferSizeFunc func(device nvml.Device) (int, nvml.Return)

	// DeviceGetAccountingModeFunc mocks the DeviceGetAccountingMode method.
	DeviceGetAccountingModeFunc func(device nvml.Device) (nvml.EnableState, nvml.Return)

	// DeviceGetAccountingPidsFunc mocks the DeviceGetAccountingPids method.
	DeviceGetAccountingPidsFunc func(device nvml.Device) ([]int, nvml.Return)

	// DeviceGetAccountingStatsFunc mocks the DeviceGetAccountingStats method.
	DeviceGetAccountingStatsFunc func(device nvml.Device, v uint32) (nvml.AccountingStats, nvml.Return)

	// DeviceGetActiveVgpusFunc mocks the DeviceGetActiveVgpus method.
	DeviceGetActiveVgpusFunc func(device nvml.Device) ([]nvml.VgpuInstance, nvml.Return)

	// DeviceGetAdaptiveClockInfoStatusFunc mocks the DeviceGetAdaptiveClockInfoStatus method.
	DeviceGetAdaptiveClockInfoStatusFunc func(device nvml.Device) (uint32, nvml.Return)

	// DeviceGetAddressingModeFunc mocks the DeviceGetAddressingMode method.
	DeviceGetAddressingModeFunc func(device nvml.Device) (nvml.DeviceAddressingMode, nvml.Return)

	// DeviceGetApplicationsClockFunc mocks the DeviceGetApplicationsClock method.
	DeviceGetApplicationsClockFunc func(device nvml.Device, clockType nvml.ClockType) (uint32, nvml.Return)

	// DeviceGetArchitectureFunc mocks the DeviceGetArchitecture method.
	DeviceGetArchitectureFunc func(device nvml.Device) (nvml.DeviceArchitecture, nvml.Return)

	// DeviceGetAttributesFunc mocks the DeviceGetAttributes method.
	DeviceGetAttributesFunc func(device nvml.Device) (nvml.DeviceAttributes, nvml.Return)

	// DeviceGetAutoBoostedClocksEnabledFunc mocks the DeviceGetAutoBoostedClocksEnabled method.
	DeviceGetAutoBoostedClocksEnabledFunc func(device nvml.Device) (nvml.EnableState, nvml.EnableState, nvml.Return)

	// DeviceGetBAR1MemoryInfoFunc mocks the DeviceGetBAR1MemoryInfo method.
	DeviceGetBAR1MemoryInfoFunc func(device nvml.Device) (nvml.BAR1Memory, nvml.Return)

	// DeviceGetBoardIdFunc mocks the DeviceGetBoardId method.
	DeviceGetBoardIdFunc func(device nvml.Device) (uint32, nvml.Return)

	// DeviceGetBoardPartNumberFunc mocks the DeviceGetBoardPartNumber method.
	DeviceGetBoardPartNumberFunc func(device nvml.Device) (string, nvml.Return)

	// DeviceGetBrandFunc mocks the DeviceGetBrand method.
	DeviceGetBrandFunc func(device nvml.Device) (nvml.BrandType, nvml.Return)

	// DeviceGetBridgeChipInfoFunc mocks the DeviceGetBridgeChipInfo method.
	DeviceGetBridgeChipInfoFunc func(device nvml.Device) (nvml.BridgeChipHierarchy, nvml.Return)

	// DeviceGetBusTypeFunc mocks the DeviceGetBusType method.
	DeviceGetBusTypeFunc func(device nvml.Device) (nvml.BusType, nvml.Return)

	// DeviceGetC2cModeInfoVFunc mocks the DeviceGetC2cModeInfoV method.
	DeviceGetC2cModeInfoVFunc func(device nvml.Device) nvml.C2cModeInfoHandler

	// DeviceGetCapabilitiesFunc mocks the DeviceGetCapabilities method.
	DeviceGetCapabilitiesFunc func(device nvml.Device) (nvml.DeviceCapabilities, nvml.Return)

	// DeviceGetClkMonStatusFunc mocks the DeviceGetClkMonStatus method.
	DeviceGetClkMonStatusFunc func(device nvml.Device) (nvml.ClkMonStatus, nvml.Return)

	// DeviceGetClockFunc mocks the DeviceGetClock method.
	DeviceGetClockFunc func(device nvml.Device, clockType nvml.ClockType, clockId nvml.ClockId) (uint32, nvml.Return)

	// DeviceGetClockInfoFunc mocks the DeviceGetClockInfo method.
	DeviceGetClockInfoFunc func(device nvml.Device, clockType nvml.ClockType) (uint32, nvml.Return)

	// DeviceGetClockOffsetsFunc mocks the DeviceGetClockOffsets method.
	DeviceGetClockOffsetsFunc func(device nvml.Device) (nvml.ClockOffset, nvml.Return)

	// DeviceGetComputeInstanceIdFunc mocks the DeviceGetComputeInstanceId method.
	DeviceGetComputeInstanceIdFunc func(device nvml.Device) (int, nvml.Return)

	// DeviceGetComputeModeFunc mocks the DeviceGetComputeMode method.
	DeviceGetComputeModeFunc func(device nvml.Device) (nvml.ComputeMode, nvml.Return)

	// DeviceGetComputeRunningProcessesFunc mocks the DeviceGetComputeRunningProcesses method.
	DeviceGetComputeRunningProcessesFunc func(device nvml.Device) ([]nvml.ProcessInfo, nvml.Return)

	// DeviceGetConfComputeGpuAttestationReportFunc mocks the DeviceGetConfComputeGpuAttestationReport method.
	DeviceGetConfComputeGpuAttestationReportFunc func(device nvml.Device, confComputeGpuAttestationReport *nvml.ConfComputeGpuAttestationReport) nvml.Return

	// DeviceGetConfComputeGpuCertificateFunc mocks the DeviceGetConfComputeGpuCertificate method.
	DeviceGetConfComputeGpuCertificateFunc func(device nvml.Device) (nvml.ConfComputeGpuCertificate, nvml.Return)

	// DeviceGetConfComputeMemSizeInfoFunc mocks the DeviceGetConfComputeMemSizeInfo method.
	DeviceGetConfComputeMemSizeInfoFunc func(device nvml.Device) (nvml.ConfComputeMemSizeInfo, nvml.Return)

	// DeviceGetConfComputeProtectedMemoryUsageFunc mocks the DeviceGetConfComputeProtectedMemoryUsage method.
	DeviceGetConfComputeProtectedMemoryUsageFunc func(device nvml.Device) (nvml.Memory, nvml.Return)

	// DeviceGetCoolerInfoFunc mocks the DeviceGetCoolerInfo method.
	DeviceGetCoolerInfoFunc func(device nvml.Device) (nvml.CoolerInfo, nvml.Return)

	// DeviceGetCountFunc mocks the DeviceGetCount method.
	DeviceGetCountFunc func() (int, nvml.Return)

	// DeviceGetCpuAffinityFunc mocks the DeviceGetCpuAffinity method.
	DeviceGetCpuAffinityFunc func(device nvml.Device, n int) ([]uint, nvml.Return)

	// DeviceGetCpuAffinityWithinScopeFunc mocks the DeviceGetCpuAffinityWithinScope method.
	DeviceGetCpuAffinityWithinScopeFunc func(device nvml.Device, n int, affinityScope nvml.AffinityScope) ([]uint, nvml.Return)

	// DeviceGetCreatableVgpusFunc mocks the DeviceGetCreatableVgpus method.
	DeviceGetCreatableVgpusFunc func(device nvml.Device) ([]nvml.VgpuTypeId, nvml.Return)

	// DeviceGetCudaComputeCapabilityFunc mocks the DeviceGetCudaComputeCapability method.
	DeviceGetCudaComputeCapabilityFunc func(device nvml.Device) (int, int, nvml.Return)

	// DeviceGetCurrPcieLinkGenerationFunc mocks the DeviceGetCurrPcieLinkGeneration method.
	DeviceGetCurrPcieLinkGenerationFunc func(device nvml.Device) (int, nvml.Return)

	// DeviceGetCurrPcieLinkWidthFunc mocks the DeviceGetCurrPcieLinkWidth method.
	DeviceGetCurrPcieLinkWidthFunc func(device nvml.Device) (int, nvml.Return)

	// DeviceGetCurrentClockFreqsFunc mocks the DeviceGetCurrentClockFreqs method.
	DeviceGetCurrentClockFreqsFunc func(device nvml.Device) (nvml.DeviceCurrentClockFreqs, nvml.Return)

	// DeviceGetCurrentClocksEventReasonsFunc mocks the DeviceGetCurrentClocksEventReasons method.
	DeviceGetCurrentClocksEventReasonsFunc func(device nvml.Device) (uint64, nvml.Return)

	// DeviceGetCurrentClocksThrottleReasonsFunc mocks the DeviceGetCurrentClocksThrottleReasons method.
	DeviceGetCurrentClocksThrottleReasonsFunc func(device nvml.Device) (uint64, nvml.Return)

	// DeviceGetDecoderUtilizationFunc mocks the DeviceGetDecoderUtilization method.
	DeviceGetDecoderUtilizationFunc func(device nvml.Device) (uint32, uint32, nvml.Return)

	// DeviceGetDefaultApplicationsClockFunc mocks the DeviceGetDefaultApplicationsClock method.
	DeviceGetDefaultApplicationsClockFunc func(device nvml.Device, clockType nvml.ClockType) (uint32, nvml.Return)

	// DeviceGetDefaultEccModeFunc mocks the DeviceGetDefaultEccMode method.
	DeviceGetDefaultEccModeFunc func(device nvml.Device) (nvml.EnableState, nvml.Return)

	// DeviceGetDetailedEccErrorsFunc mocks the DeviceGetDetailedEccErrors method.
	DeviceGetDetailedEccErrorsFunc func(device nvml.Device, memoryErrorType nvml.MemoryErrorType, eccCounterType nvml.EccCounterType) (nvml.EccErrorCounts, nvml.Return)

	// DeviceGetDeviceHandleFromMigDeviceHandleFunc mocks the DeviceGetDeviceHandleFromMigDeviceHandle method.
	DeviceGetDeviceHandleFromMigDeviceHandleFunc func(device nvml.Device) (nvml.Device, nvml.Return)

	// DeviceGetDisplayActiveFunc mocks the DeviceGetDisplayActive method.
	DeviceGetDisplayActiveFunc func(device nvml.Device) (nvml.EnableState, nvml.Return)

	// DeviceGetDisplayModeFunc mocks the DeviceGetDisplayMode method.
	DeviceGetDisplayModeFunc func(device nvml.Device) (nvml.EnableState, nvml.Return)

	// DeviceGetDramEncryptionModeFunc mocks the DeviceGetDramEncryptionMode method.
	DeviceGetDramEncryptionModeFunc func(device nvml.Device) (nvml.DramEncryptionInfo, nvml.DramEncryptionInfo, nvml.Return)

	// DeviceGetDriverModelFunc mocks the DeviceGetDriverModel method.
	DeviceGetDriverModelFunc func(device nvml.Device) (nvml.DriverModel, nvml.DriverModel, nvml.Return)

	// DeviceGetDriverModel_v2Func mocks the DeviceGetDriverModel_v2 method.
	DeviceGetDriverModel_v2Func func(device nvml.Device) (nvml.DriverModel, nvml.DriverModel, nvml.Return)

	// DeviceGetDynamicPstatesInfoFunc mocks the DeviceGetDynamicPstatesInfo method.
	DeviceGetDynamicPstatesInfoFunc func(device nvml.Device) (nvml.GpuDynamicPstatesInfo, nvml.Return)

	// DeviceGetEccModeFunc mocks the DeviceGetEccMode method.
	DeviceGetEccModeFunc func(device nvml.Device) (nvml.EnableState, nvml.EnableState, nvml.Return)

	// DeviceGetEncoderCapacityFunc mocks the DeviceGetEncoderCapacity method.
	DeviceGetEncoderCapacityFunc func(device nvml.Device, encoderType nvml.EncoderType) (int, nvml.Return)

	// DeviceGetEncoderSessionsFunc mocks the DeviceGetEncoderSessions method.
	DeviceGetEncoderSessionsFunc func(device nvml.Device) ([]nvml.EncoderSessionInfo, nvml.Return)

	// DeviceGetEncoderStatsFunc mocks the DeviceGetEncoderStats method.
	DeviceGetEncoderStatsFunc func(device nvml.Device) (int, uint32, uint32, nvml.Return)

	// DeviceGetEncoderUtilizationFunc mocks the DeviceGetEncoderUtilization method.
	DeviceGetEncoderUtilizationFunc func(device nvml.Device) (uint32, uint32, nvml.Return)

	// DeviceGetEnforcedPowerLimitFunc mocks the DeviceGetEnforcedPowerLimit method.
	DeviceGetEnforcedPowerLimitFunc func(device nvml.Device) (uint32, nvml.Return)

	// DeviceGetFBCSessionsFunc mocks the DeviceGetFBCSessions method.
	DeviceGetFBCSessionsFunc func(device nvml.Device) ([]nvml.FBCSessionInfo, nvml.Return)

	// DeviceGetFBCStatsFunc mocks the DeviceGetFBCStats method.
	DeviceGetFBCStatsFunc func(device nvml.Device) (nvml.FBCStats, nvml.Return)

	// DeviceGetFanControlPolicy_v2Func mocks the DeviceGetFanControlPolicy_v2 method.
	DeviceGetFanControlPolicy_v2Func func(device nvml.Device, n int) (nvml.FanControlPolicy, nvml.Return)

	// DeviceGetFanSpeedFunc mocks the DeviceGetFanSpeed method.
	DeviceGetFanSpeedFunc func(device nvml.Device) (uint32, nvml.Return)

	// DeviceGetFanSpeedRPMFunc mocks the DeviceGetFanSpeedRPM method.
	DeviceGetFanSpeedRPMFunc func(device nvml.Device) (nvml.FanSpeedInfo, nvml.Return)

	// DeviceGetFanSpeed_v2Func mocks the DeviceGetFanSpeed_v2 method.
	DeviceGetFanSpeed_v2Func func(device nvml.Device, n int) (uint32, nvml.Return)

	// DeviceGetFieldValuesFunc mocks the DeviceGetFieldValues method.
	DeviceGetFieldValuesFunc func(device nvml.Device, fieldValues []nvml.FieldValue) nvml.Return

	// DeviceGetGpcClkMinMaxVfOffsetFunc mocks the DeviceGetGpcClkMinMaxVfOffset method.
	DeviceGetGpcClkMinMaxVfOffsetFunc func(device nvml.Device) (int, int, nvml.Return)

	// DeviceGetGpcClkVfOffsetFunc mocks the DeviceGetGpcClkVfOffset method.
	DeviceGetGpcClkVfOffsetFunc func(device nvml.Device) (int, nvml.Return)

	// DeviceGetGpuFabricInfoFunc mocks the DeviceGetGpuFabricInfo method.
	DeviceGetGpuFabricInfoFunc func(device nvml.Device) (nvml.GpuFabricInfo, nvml.Return)

	// DeviceGetGpuFabricInfoVFunc mocks the DeviceGetGpuFabricInfoV method.
	DeviceGetGpuFabricInfoVFunc func(device nvml.Device) nvml.GpuFabricInfoHandler

	// DeviceGetGpuInstanceByIdFunc mocks the DeviceGetGpuInstanceById method.
	DeviceGetGpuInstanceByIdFunc func(device nvml.Device, n int) (nvml.GpuInstance, nvml.Return)

	// DeviceGetGpuInstanceIdFunc mocks the DeviceGetGpuInstanceId method.
	DeviceGetGpuInstanceIdFunc func(device nvml.Device) (int, nvml.Return)

	// DeviceGetGpuInstancePossiblePlacementsFunc mocks the DeviceGetGpuInstancePossiblePlacements method.
	DeviceGetGpuInstancePossiblePlacementsFunc func(device nvml.Device, gpuInstanceProfileInfo *nvml.GpuInstanceProfileInfo) ([]nvml.GpuInstancePlacement, nvml.Return)

	// DeviceGetGpuInstanceProfileInfoFunc mocks the DeviceGetGpuInstanceProfileInfo method.
	DeviceGetGpuInstanceProfileInfoFunc func(device nvml.Device, n int) (nvml.GpuInstanceProfileInfo, nvml.Return)

	// DeviceGetGpuInstanceProfileInfoByIdVFunc mocks the DeviceGetGpuInstanceProfileInfoByIdV method.
	DeviceGetGpuInstanceProfileInfoByIdVFunc func(device nvml.Device, n int) nvml.GpuInstanceProfileInfoByIdHandler

	// DeviceGetGpuInstanceProfileInfoVFunc mocks the DeviceGetGpuInstanceProfileInfoV method.
	DeviceGetGpuInstanceProfileInfoVFunc func(device nvml.Device, n int) nvml.GpuInstanceProfileInfoHandler

	// DeviceGetGpuInstanceRemainingCapacityFunc mocks the DeviceGetGpuInstanceRemainingCapacity method.
	DeviceGetGpuInstanceRemainingCapacityFunc func(device nvml.Device, gpuInstanceProfileInfo *nvml.GpuInstanceProfileInfo) (int, nvml.Return)

	// DeviceGetGpuInstancesFunc mocks the DeviceGetGpuInstances method.
	DeviceGetGpuInstancesFunc func(device nvml.Device, gpuInstanceProfileInfo *nvml.GpuInstanceProfileInfo) ([]nvml.GpuInstance, nvml.Return)

	// DeviceGetGpuMaxPcieLinkGenerationFunc mocks the DeviceGetGpuMaxPcieLinkGeneration method.
	DeviceGetGpuMaxPcieLinkGenerationFunc func(device nvml.Device) (int, nvml.Return)

	// DeviceGetGpuOperationModeFunc mocks the DeviceGetGpuOperationMode method.
	DeviceGetGpuOperationModeFunc func(device nvml.Device) (nvml.GpuOperationMode, nvml.GpuOperationMode, nvml.Return)

	// DeviceGetGraphicsRunningProcessesFunc mocks the DeviceGetGraphicsRunningProcesses method.
	DeviceGetGraphicsRunningProcessesFunc func(device nvml.Device) ([]nvml.ProcessInfo, nvml.Return)

	// DeviceGetGridLicensableFeaturesFunc mocks the DeviceGetGridLicensableFeatures method.
	DeviceGetGridLicensableFeaturesFunc func(device nvml.Device) (nvml.GridLicensableFeatures, nvml.Return)

	// DeviceGetGspFirmwareModeFunc mocks the DeviceGetGspFirmwareMode method.
	DeviceGetGspFirmwareModeFunc func(device nvml.Device) (bool, bool, nvml.Return)

	// DeviceGetGspFirmwareVersionFunc mocks the DeviceGetGspFirmwareVersion method.
	DeviceGetGspFirmwareVersionFunc func(device nvml.Device) (string, nvml.Return)

	// DeviceGetHandleByIndexFunc mocks the DeviceGetHandleByIndex method.
	DeviceGetHandleByIndexFunc func(n int) (nvml.Device, nvml.Return)

	// DeviceGetHandleByPciBusIdFunc mocks the DeviceGetHandleByPciBusId method.
	DeviceGetHandleByPciBusIdFunc func(s string) (nvml.Device, nvml.Return)

	// DeviceGetHandleBySerialFunc mocks the DeviceGetHandleBySerial method.
	DeviceGetHandleBySerialFunc func(s string) (nvml.Device, nvml.Return)

	// DeviceGetHandleByUUIDFunc mocks the DeviceGetHandleByUUID method.
	DeviceGetHandleByUUIDFunc func(s string) (nvml.Device, nvml.Return)

	// DeviceGetHandleByUUIDVFunc mocks the DeviceGetHandleByUUIDV method.
	DeviceGetHandleByUUIDVFunc func(uUID *nvml.UUID) (nvml.Device, nvml.Return)

	// DeviceGetHostVgpuModeFunc mocks the DeviceGetHostVgpuMode method.
	DeviceGetHostVgpuModeFunc func(device nvml.Device) (nvml.HostVgpuMode, nvml.Return)

	// DeviceGetIndexFunc mocks the DeviceGetIndex method.
	DeviceGetIndexFunc func(device nvml.Device) (int, nvml.Return)

	// DeviceGetInforomConfigurationChecksumFunc mocks the DeviceGetInforomConfigurationChecksum method.
	DeviceGetInforomConfigurationChecksumFunc func(device nvml.Device) (uint32, nvml.Return)

	// DeviceGetInforomImageVersionFunc mocks the DeviceGetInforomImageVersion method.
	DeviceGetInforomImageVersionFunc func(device nvml.Device) (string, nvml.Return)

	// DeviceGetInforomVersionFunc mocks the DeviceGetInforomVersion method.
	DeviceGetInforomVersionFunc func(device nvml.Device, inforomObject nvml.InforomObject) (string, nvml.Return)

	// DeviceGetIrqNumFunc mocks the DeviceGetIrqNum method.
	DeviceGetIrqNumFunc func(device nvml.Device) (int, nvml.Return)

	// DeviceGetJpgUtilizationFunc mocks the DeviceGetJpgUtilization method.
	DeviceGetJpgUtilizationFunc func(device nvml.Device) (uint32, uint32, nvml.Return)

	// DeviceGetLastBBXFlushTimeFunc mocks the DeviceGetLastBBXFlushTime method.
	DeviceGetLastBBXFlushTimeFunc func(device nvml.Device) (uint64, uint, nvml.Return)

	// DeviceGetMPSComputeRunningProcessesFunc mocks the DeviceGetMPSComputeRunningProcesses method.
	DeviceGetMPSComputeRunningProcessesFunc func(device nvml.Device) ([]nvml.ProcessInfo, nvml.Return)

	// DeviceGetMarginTemperatureFunc mocks the DeviceGetMarginTemperature method.
	DeviceGetMarginTemperatureFunc func(device nvml.Device) (nvml.MarginTemperature, nvml.Return)

	// DeviceGetMaxClockInfoFunc mocks the DeviceGetMaxClockInfo method.
	DeviceGetMaxClockInfoFunc func(device nvml.Device, clockType nvml.ClockType) (uint32, nvml.Return)

	// DeviceGetMaxCustomerBoostClockFunc mocks the DeviceGetMaxCustomerBoostClock method.
	DeviceGetMaxCustomerBoostClockFunc func(device nvml.Device, clockType nvml.ClockType) (uint32, nvml.Return)

	// DeviceGetMaxMigDeviceCountFunc mocks the DeviceGetMaxMigDeviceCount method.
	DeviceGetMaxMigDeviceCountFunc func(device nvml.Device) (int, nvml.Return)

	// DeviceGetMaxPcieLinkGenerationFunc mocks the DeviceGetMaxPcieLinkGeneration method.
	DeviceGetMaxPcieLinkGenerationFunc func(device nvml.Device) (int, nvml.Return)

	// DeviceGetMaxPcieLinkWidthFunc mocks the DeviceGetMaxPcieLinkWidth method.
	DeviceGetMaxPcieLinkWidthFunc func(device nvml.Device) (int, nvml.Return)

	// DeviceGetMemClkMinMaxVfOffsetFunc mocks the DeviceGetMemClkMinMaxVfOffset method.
	DeviceGetMemClkMinMaxVfOffsetFunc func(device nvml.Device) (int, int, nvml.Return)

	// DeviceGetMemClkVfOffsetFunc mocks the DeviceGetMemClkVfOffset method.
	DeviceGetMemClkVfOffsetFunc func(device nvml.Device) (int, nvml.Return)

	// DeviceGetMemoryAffinityFunc mocks the DeviceGetMemoryAffinity method.
	DeviceGetMemoryAffinityFunc func(device nvml.Device, n int, affinityScope nvml.AffinityScope) ([]uint, nvml.Return)

	// DeviceGetMemoryBusWidthFunc mocks the DeviceGetMemoryBusWidth method.
	DeviceGetMemoryBusWidthFunc func(device nvml.Device) (uint32, nvml.Return)

	// DeviceGetMemoryErrorCounterFunc mocks the DeviceGetMemoryErrorCounter method.
	DeviceGetMemoryErrorCounterFunc func(device nvml.Device, memoryErrorType nvml.MemoryErrorType, eccCounterType nvml.EccCounterType, memoryLocation nvml.MemoryLocation) (uint64, nvml.Return)

	// DeviceGetMemoryInfoFunc mocks the DeviceGetMemoryInfo method.
	DeviceGetMemoryInfoFunc func(device nvml.Device) (nvml.Memory, nvml.Return)

	// DeviceGetMemoryInfo_v2Func mocks the DeviceGetMemoryInfo_v2 method.
	DeviceGetMemoryInfo_v2Func func(device nvml.Device) (nvml.Memory_v2, nvml.Return)

	// DeviceGetMigDeviceHandleByIndexFunc mocks the DeviceGetMigDeviceHandleByIndex method.
	DeviceGetMigDeviceHandleByIndexFunc func(device nvml.Device, n int) (nvml.Device, nvml.Return)

	// DeviceGetMigModeFunc mocks the DeviceGetMigMode method.
	DeviceGetMigModeFunc func(device nvml.Device) (int, int, nvml.Return)

	// DeviceGetMinMaxClockOfPStateFunc mocks the DeviceGetMinMaxClockOfPState method.
	DeviceGetMinMaxClockOfPStateFunc func(device nvml.Device, clockType nvml.ClockType, pstates nvml.Pstates) (uint32, uint32, nvml.Return)

	// DeviceGetMinMaxFanSpeedFunc mocks the DeviceGetMinMaxFanSpeed method.
	DeviceGetMinMaxFanSpeedFunc func(device nvml.Device) (int, int, nvml.Return)

	// DeviceGetMinorNumberFunc mocks the DeviceGetMinorNumber method.
	DeviceGetMinorNumberFunc func(device nvml.Device) (int, nvml.Return)

	// DeviceGetModuleIdFunc mocks the DeviceGetModuleId method.
	DeviceGetModuleIdFunc func(device nvml.Device) (int, nvml.Return)

	// DeviceGetMultiGpuBoardFunc mocks the DeviceGetMultiGpuBoard method.
	DeviceGetMultiGpuBoardFunc func(device nvml.Device) (int, nvml.Return)

	// DeviceGetNameFunc mocks the DeviceGetName method.
	DeviceGetNameFunc func(device nvml.Device) (string, nvml.Return)

	// DeviceGetNumFansFunc mocks the DeviceGetNumFans method.
	DeviceGetNumFansFunc func(device nvml.Device) (int, nvml.Return)

	// DeviceGetNumGpuCoresFunc mocks the DeviceGetNumGpuCores method.
	DeviceGetNumGpuCoresFunc func(device nvml.Device) (int, nvml.Return)

	// DeviceGetNumaNodeIdFunc mocks the DeviceGetNumaNodeId method.
	DeviceGetNumaNodeIdFunc func(device nvml.Device) (int, nvml.Return)

	// DeviceGetNvLinkCapabilityFunc mocks the DeviceGetNvLinkCapability method.
	DeviceGetNvLinkCapabilityFunc func(device nvml.Device, n int, nvLinkCapability nvml.NvLinkCapability) (uint32, nvml.Return)

	// DeviceGetNvLinkErrorCounterFunc mocks the DeviceGetNvLinkErrorCounter method.
	DeviceGetNvLinkErrorCounterFunc func(device nvml.Device, n int, nvLinkErrorCounter nvml.NvLinkErrorCounter) (uint64, nvml.Return)

	// DeviceGetNvLinkInfoFunc mocks the DeviceGetNvLinkInfo method.
	DeviceGetNvLinkInfoFunc func(device nvml.Device) nvml.NvLinkInfoHandler

	// DeviceGetNvLinkRemoteDeviceTypeFunc mocks the DeviceGetNvLinkRemoteDeviceType method.
	DeviceGetNvLinkRemoteDeviceTypeFunc func(device nvml.Device, n int) (nvml.IntNvLinkDeviceType, nvml.Return)

	// DeviceGetNvLinkRemotePciInfoFunc mocks the DeviceGetNvLinkRemotePciInfo method.
	DeviceGetNvLinkRemotePciInfoFunc func(device nvml.Device, n int) (nvml.PciInfo, nvml.Return)

	// DeviceGetNvLinkStateFunc mocks the DeviceGetNvLinkState method.
	DeviceGetNvLinkStateFunc func(device nvml.Device, n int) (nvml.EnableState, nvml.Return)

	// DeviceGetNvLinkUtilizationControlFunc mocks the DeviceGetNvLinkUtilizationControl method.
	DeviceGetNvLinkUtilizationControlFunc func(device nvml.Device, n1 int, n2 int) (nvml.NvLinkUtilizationControl, nvml.Return)

	// DeviceGetNvLinkUtilizationCounterFunc mocks the DeviceGetNvLinkUtilizationCounter method.
	DeviceGetNvLinkUtilizationCounterFunc func(device nvml.Device, n1 int, n2 int) (uint64, uint64, nvml.Return)

	// DeviceGetNvLinkVersionFunc mocks the DeviceGetNvLinkVersion method.
	DeviceGetNvLinkVersionFunc func(device nvml.Device, n int) (uint32, nvml.Return)

	// DeviceGetNvlinkBwModeFunc mocks the DeviceGetNvlinkBwMode method.
	DeviceGetNvlinkBwModeFunc func(device nvml.Device) (nvml.NvlinkGetBwMode, nvml.Return)

	// DeviceGetNvlinkSupportedBwModesFunc mocks the DeviceGetNvlinkSupportedBwModes method.
	DeviceGetNvlinkSupportedBwModesFunc func(device nvml.Device) (nvml.NvlinkSupportedBwModes, nvml.Return)

	// DeviceGetOfaUtilizationFunc mocks the DeviceGetOfaUtilization method.
	DeviceGetOfaUtilizationFunc func(device nvml.Device) (uint32, uint32, nvml.Return)

	// DeviceGetP2PStatusFunc mocks the DeviceGetP2PStatus method.
	DeviceGetP2PStatusFunc func(device1 nvml.Device, device2 nvml.Device, gpuP2PCapsIndex nvml.GpuP2PCapsIndex) (nvml.GpuP2PStatus, nvml.Return)

	// DeviceGetPciInfoFunc mocks the DeviceGetPciInfo method.
	DeviceGetPciInfoFunc func(device nvml.Device) (nvml.PciInfo, nvml.Return)

	// DeviceGetPciInfoExtFunc mocks the DeviceGetPciInfoExt method.
	DeviceGetPciInfoExtFunc func(device nvml.Device) (nvml.PciInfoExt, nvml.Return)

	// DeviceGetPcieLinkMaxSpeedFunc mocks the DeviceGetPcieLinkMaxSpeed method.
	DeviceGetPcieLinkMaxSpeedFunc func(device nvml.Device) (uint32, nvml.Return)

	// DeviceGetPcieReplayCounterFunc mocks the DeviceGetPcieReplayCounter method.
	DeviceGetPcieReplayCounterFunc func(device nvml.Device) (int, nvml.Return)

	// DeviceGetPcieSpeedFunc mocks the DeviceGetPcieSpeed method.
	DeviceGetPcieSpeedFunc func(device nvml.Device) (int, nvml.Return)

	// DeviceGetPcieThroughputFunc mocks the DeviceGetPcieThroughput method.
	DeviceGetPcieThroughputFunc func(device nvml.Device, pcieUtilCounter nvml.PcieUtilCounter) (uint32, nvml.Return)

	// DeviceGetPdiFunc mocks the DeviceGetPdi method.
	DeviceGetPdiFunc func(device nvml.Device) (nvml.Pdi, nvml.Return)

	// DeviceGetPerformanceModesFunc mocks the DeviceGetPerformanceModes method.
	DeviceGetPerformanceModesFunc func(device nvml.Device) (nvml.DevicePerfModes, nvml.Return)

	// DeviceGetPerformanceStateFunc mocks the DeviceGetPerformanceState method.
	DeviceGetPerformanceStateFunc func(device nvml.Device) (nvml.Pstates, nvml.Return)

	// DeviceGetPersistenceModeFunc mocks the DeviceGetPersistenceMode method.
	DeviceGetPersistenceModeFunc func(device nvml.Device) (nvml.EnableState, nvml.Return)

	// DeviceGetPgpuMetadataStringFunc mocks the DeviceGetPgpuMetadataString method.
	DeviceGetPgpuMetadataStringFunc func(device nvml.Device) (string, nvml.Return)

	// DeviceGetPlatformInfoFunc mocks the DeviceGetPlatformInfo method.
	DeviceGetPlatformInfoFunc func(device nvml.Device) (nvml.PlatformInfo, nvml.Return)

	// DeviceGetPowerManagementDefaultLimitFunc mocks the DeviceGetPowerManagementDefaultLimit method.
	DeviceGetPowerManagementDefaultLimitFunc func(device nvml.Device) (uint32, nvml.Return)

	// DeviceGetPowerManagementLimitFunc mocks the DeviceGetPowerManagementLimit method.
	DeviceGetPowerManagementLimitFunc func(device nvml.Device) (uint32, nvml.Return)

	// DeviceGetPowerManagementLimitConstraintsFunc mocks the DeviceGetPowerManagementLimitConstraints method.
	DeviceGetPowerManagementLimitConstraintsFunc func(device nvml.Device) (uint32, uint32, nvml.Return)

	// DeviceGetPowerManagementModeFunc mocks the DeviceGetPowerManagementMode method.
	DeviceGetPowerManagementModeFunc func(device nvml.Device) (nvml.EnableState, nvml.Return)

	// DeviceGetPowerMizerMode_v1Func mocks the DeviceGetPowerMizerMode_v1 method.
	DeviceGetPowerMizerMode_v1Func func(device nvml.Device) (nvml.DevicePowerMizerModes_v1, nvml.Return)

	// DeviceGetPowerSourceFunc mocks the DeviceGetPowerSource method.
	DeviceGetPowerSourceFunc func(device nvml.Device) (nvml.PowerSource, nvml.Return)

	// DeviceGetPowerStateFunc mocks the DeviceGetPowerState method.
	DeviceGetPowerStateFunc func(device nvml.Device) (nvml.Pstates, nvml.Return)

	// DeviceGetPowerUsageFunc mocks the DeviceGetPowerUsage method.
	DeviceGetPowerUsageFunc func(device nvml.Device) (uint32, nvml.Return)

	// DeviceGetProcessUtilizationFunc mocks the DeviceGetProcessUtilization method.
	DeviceGetProcessUtilizationFunc func(device nvml.Device, v uint64) ([]nvml.ProcessUtilizationSample, nvml.Return)

	// DeviceGetProcessesUtilizationInfoFunc mocks the DeviceGetProcessesUtilizationInfo method.
	DeviceGetProcessesUtilizationInfoFunc func(device nvml.Device) (nvml.ProcessesUtilizationInfo, nvml.Return)

	// DeviceGetRemappedRowsFunc mocks the DeviceGetRemappedRows method.
	DeviceGetRemappedRowsFunc func(device nvml.Device) (int, int, bool, bool, nvml.Return)

	// DeviceGetRepairStatusFunc mocks the DeviceGetRepairStatus method.
	DeviceGetRepairStatusFunc func(device nvml.Device) (nvml.RepairStatus, nvml.Return)

	// DeviceGetRetiredPagesFunc mocks the DeviceGetRetiredPages method.
	DeviceGetRetiredPagesFunc func(device nvml.Device, pageRetirementCause nvml.PageRetirementCause) ([]uint64, nvml.Return)

	// DeviceGetRetiredPagesPendingStatusFunc mocks the DeviceGetRetiredPagesPendingStatus method.
	DeviceGetRetiredPagesPendingStatusFunc func(device nvml.Device) (nvml.EnableState, nvml.Return)

	// DeviceGetRetiredPages_v2Func mocks the DeviceGetRetiredPages_v2 method.
	DeviceGetRetiredPages_v2Func func(device nvml.Device, pageRetirementCause nvml.PageRetirementCause) ([]uint64, []uint64, nvml.Return)

	// DeviceGetRowRemapperHistogramFunc mocks the DeviceGetRowRemapperHistogram method.
	DeviceGetRowRemapperHistogramFunc func(device nvml.Device) (nvml.RowRemapperHistogramValues, nvml.Return)

	// DeviceGetRunningProcessDetailListFunc mocks the DeviceGetRunningProcessDetailList method.
	DeviceGetRunningProcessDetailListFunc func(device nvml.Device) (nvml.ProcessDetailList, nvml.Return)

	// DeviceGetSamplesFunc mocks the DeviceGetSamples method.
	DeviceGetSamplesFunc func(device nvml.Device, samplingType nvml.SamplingType, v uint64) (nvml.ValueType, []nvml.Sample, nvml.Return)

	// DeviceGetSerialFunc mocks the DeviceGetSerial method.
	DeviceGetSerialFunc func(device nvml.Device) (string, nvml.Return)

	// DeviceGetSramEccErrorStatusFunc mocks the DeviceGetSramEccErrorStatus method.
	DeviceGetSramEccErrorStatusFunc func(device nvml.Device) (nvml.EccSramErrorStatus, nvml.Return)

	// DeviceGetSramUniqueUncorrectedEccErrorCountsFunc mocks the DeviceGetSramUniqueUncorrectedEccErrorCounts method.
	DeviceGetSramUniqueUncorrectedEccErrorCountsFunc func(device nvml.Device, eccSramUniqueUncorrectedErrorCounts *nvml.EccSramUniqueUncorrectedErrorCounts) nvml.Return

	// DeviceGetSupportedClocksEventReasonsFunc mocks the DeviceGetSupportedClocksEventReasons method.
	DeviceGetSupportedClocksEventReasonsFunc func(device nvml.Device) (uint64, nvml.Return)

	// DeviceGetSupportedClocksThrottleReasonsFunc mocks the DeviceGetSupportedClocksThrottleReasons method.
	DeviceGetSupportedClocksThrottleReasonsFunc func(device nvml.Device) (uint64, nvml.Return)

	// DeviceGetSupportedEventTypesFunc mocks the DeviceGetSupportedEventTypes method.
	DeviceGetSupportedEventTypesFunc func(device nvml.Device) (uint64, nvml.Return)

	// DeviceGetSupportedGraphicsClocksFunc mocks the DeviceGetSupportedGraphicsClocks method.
	DeviceGetSupportedGraphicsClocksFunc func(device nvml.Device, n int) (int, uint32, nvml.Return)

	// DeviceGetSupportedMemoryClocksFunc mocks the DeviceGetSupportedMemoryClocks method.
	DeviceGetSupportedMemoryClocksFunc func(device nvml.Device) (int, uint32, nvml.Return)

	// DeviceGetSupportedPerformanceStatesFunc mocks the DeviceGetSupportedPerformanceStates method.
	DeviceGetSupportedPerformanceStatesFunc func(device nvml.Device) ([]nvml.Pstates, nvml.Return)

	// DeviceGetSupportedVgpusFunc mocks the DeviceGetSupportedVgpus method.
	DeviceGetSupportedVgpusFunc func(device nvml.Device) ([]nvml.VgpuTypeId, nvml.Return)

	// DeviceGetTargetFanSpeedFunc mocks the DeviceGetTargetFanSpeed method.
	DeviceGetTargetFanSpeedFunc func(device nvml.Device, n int) (int, nvml.Return)

	// DeviceGetTemperatureFunc mocks the DeviceGetTemperature method.
	DeviceGetTemperatureFunc func(device nvml.Device, temperatureSensors nvml.TemperatureSensors) (uint32, nvml.Return)

	// DeviceGetTemperatureThresholdFunc mocks the DeviceGetTemperatureThreshold method.
	DeviceGetTemperatureThresholdFunc func(device nvml.Device, temperatureThresholds nvml.TemperatureThresholds) (uint32, nvml.Return)

	// DeviceGetTemperatureVFunc mocks the DeviceGetTemperatureV method.
	DeviceGetTemperatureVFunc func(device nvml.Device) nvml.TemperatureHandler

	// DeviceGetThermalSettingsFunc mocks the DeviceGetThermalSettings method.
	DeviceGetThermalSettingsFunc func(device nvml.Device, v uint32) (nvml.GpuThermalSettings, nvml.Return)

	// DeviceGetTopologyCommonAncestorFunc mocks the DeviceGetTopologyCommonAncestor method.
	DeviceGetTopologyCommonAncestorFunc func(device1 nvml.Device, device2 nvml.Device) (nvml.GpuTopologyLevel, nvml.Return)

	// DeviceGetTopologyNearestGpusFunc mocks the DeviceGetTopologyNearestGpus method.
	DeviceGetTopologyNearestGpusFunc func(device nvml.Device, gpuTopologyLevel nvml.GpuTopologyLevel) ([]nvml.Device, nvml.Return)

	// DeviceGetTotalEccErrorsFunc mocks the DeviceGetTotalEccErrors method.
	DeviceGetTotalEccErrorsFunc func(device nvml.Device, memoryErrorType nvml.MemoryErrorType, eccCounterType nvml.EccCounterType) (uint64, nvml.Return)

	// DeviceGetTotalEnergyConsumptionFunc mocks the DeviceGetTotalEnergyConsumption method.
	DeviceGetTotalEnergyConsumptionFunc func(device nvml.Device) (uint64, nvml.Return)

	// DeviceGetUUIDFunc mocks the DeviceGetUUID method.
	DeviceGetUUIDFunc func(device nvml.Device) (string, nvml.Return)

	// DeviceGetUtilizationRatesFunc mocks the DeviceGetUtilizationRates method.
	DeviceGetUtilizationRatesFunc func(device nvml.Device) (nvml.Utilization, nvml.Return)

	// DeviceGetVbiosVersionFunc mocks the DeviceGetVbiosVersion method.
	DeviceGetVbiosVersionFunc func(device nvml.Device) (string, nvml.Return)

	// DeviceGetVgpuCapabilitiesFunc mocks the DeviceGetVgpuCapabilities method.
	DeviceGetVgpuCapabilitiesFunc func(device nvml.Device, deviceVgpuCapability nvml.DeviceVgpuCapability) (bool, nvml.Return)

	// DeviceGetVgpuHeterogeneousModeFunc mocks the DeviceGetVgpuHeterogeneousMode method.
	DeviceGetVgpuHeterogeneousModeFunc func(device nvml.Device) (nvml.VgpuHeterogeneousMode, nvml.Return)

	// DeviceGetVgpuInstancesUtilizationInfoFunc mocks the DeviceGetVgpuInstancesUtilizationInfo method.
	DeviceGetVgpuInstancesUtilizationInfoFunc func(device nvml.Device) (nvml.VgpuInstancesUtilizationInfo, nvml.Return)

	// DeviceGetVgpuMetadataFunc mocks the DeviceGetVgpuMetadata method.
	DeviceGetVgpuMetadataFunc func(device nvml.Device) (nvml.VgpuPgpuMetadata, nvml.Return)

	// DeviceGetVgpuProcessUtilizationFunc mocks the DeviceGetVgpuProcessUtilization method.
	DeviceGetVgpuProcessUtilizationFunc func(device nvml.Device, v uint64) ([]nvml.VgpuProcessUtilizationSample, nvml.Return)

	// DeviceGetVgpuProcessesUtilizationInfoFunc mocks the DeviceGetVgpuProcessesUtilizationInfo method.
	DeviceGetVgpuProcessesUtilizationInfoFunc func(device nvml.Device) (nvml.VgpuProcessesUtilizationInfo, nvml.Return)

	// DeviceGetVgpuSchedulerCapabilitiesFunc mocks the DeviceGetVgpuSchedulerCapabilities method.
	DeviceGetVgpuSchedulerCapabilitiesFunc func(device nvml.Device) (nvml.VgpuSchedulerCapabilities, nvml.Return)

	// DeviceGetVgpuSchedulerLogFunc mocks the DeviceGetVgpuSchedulerLog method.
	DeviceGetVgpuSchedulerLogFunc func(device nvml.Device) (nvml.VgpuSchedulerLog, nvml.Return)

	// DeviceGetVgpuSchedulerStateFunc mocks the DeviceGetVgpuSchedulerState method.
	DeviceGetVgpuSchedulerStateFunc func(device nvml.Device) (nvml.VgpuSchedulerGetState, nvml.Return)

	// DeviceGetVgpuTypeCreatablePlacementsFunc mocks the DeviceGetVgpuTypeCreatablePlacements method.
	DeviceGetVgpuTypeCreatablePlacementsFunc func(device nvml.Device, vgpuTypeId nvml.VgpuTypeId) (nvml.VgpuPlacementList, nvml.Return)

	// DeviceGetVgpuTypeSupportedPlacementsFunc mocks the DeviceGetVgpuTypeSupportedPlacements method.
	DeviceGetVgpuTypeSupportedPlacementsFunc func(device nvml.Device, vgpuTypeId nvml.VgpuTypeId) (nvml.VgpuPlacementList, nvml.Return)

	// DeviceGetVgpuUtilizationFunc mocks the DeviceGetVgpuUtilization method.
	DeviceGetVgpuUtilizationFunc func(device nvml.Device, v uint64) (nvml.ValueType, []nvml.VgpuInstanceUtilizationSample, nvml.Return)

	// DeviceGetViolationStatusFunc mocks the DeviceGetViolationStatus method.
	DeviceGetViolationStatusFunc func(device nvml.Device, perfPolicyType nvml.PerfPolicyType) (nvml.ViolationTime, nvml.Return)

	// DeviceGetVirtualizationModeFunc mocks the DeviceGetVirtualizationMode method.
	DeviceGetVirtualizationModeFunc func(device nvml.Device) (nvml.GpuVirtualizationMode, nvml.Return)

	// DeviceIsMigDeviceHandleFunc mocks the DeviceIsMigDeviceHandle method.
	DeviceIsMigDeviceHandleFunc func(device nvml.Device) (bool, nvml.Return)

	// DeviceModifyDrainStateFunc mocks the DeviceModifyDrainState method.
	DeviceModifyDrainStateFunc func(pciInfo *nvml.PciInfo, enableState nvml.EnableState) nvml.Return

	// DeviceOnSameBoardFunc mocks the DeviceOnSameBoard method.
	DeviceOnSameBoardFunc func(device1 nvml.Device, device2 nvml.Device) (int, nvml.Return)

	// DevicePowerSmoothingActivatePresetProfileFunc mocks the DevicePowerSmoothingActivatePresetProfile method.
	DevicePowerSmoothingActivatePresetProfileFunc func(device nvml.Device, powerSmoothingProfile *nvml.PowerSmoothingProfile) nvml.Return

	// DevicePowerSmoothingSetStateFunc mocks the DevicePowerSmoothingSetState method.
	DevicePowerSmoothingSetStateFunc func(device nvml.Device, powerSmoothingState *nvml.PowerSmoothingState) nvml.Return

	// DevicePowerSmoothingUpdatePresetProfileParamFunc mocks the DevicePowerSmoothingUpdatePresetProfileParam method.
	DevicePowerSmoothingUpdatePresetProfileParamFunc func(device nvml.Device, powerSmoothingProfile *nvml.PowerSmoothingProfile) nvml.Return

	// DeviceQueryDrainStateFunc mocks the DeviceQueryDrainState method.
	DeviceQueryDrainStateFunc func(pciInfo *nvml.PciInfo) (nvml.EnableState, nvml.Return)

	// DeviceReadWritePRM_v1Func mocks the DeviceReadWritePRM_v1 method.
	DeviceReadWritePRM_v1Func func(device nvml.Device, pRMTLV_v1 *nvml.PRMTLV_v1) nvml.Return

	// DeviceRegisterEventsFunc mocks the DeviceRegisterEvents method.
	DeviceRegisterEventsFunc func(device nvml.Device, v uint64, eventSet nvml.EventSet) nvml.Return

	// DeviceRemoveGpuFunc mocks the DeviceRemoveGpu method.
	DeviceRemoveGpuFunc func(pciInfo *nvml.PciInfo) nvml.Return

	// DeviceRemoveGpu_v2Func mocks the DeviceRemoveGpu_v2 method.
	DeviceRemoveGpu_v2Func func(pciInfo *nvml.PciInfo, detachGpuState nvml.DetachGpuState, pcieLinkState nvml.PcieLinkState) nvml.Return

	// DeviceResetApplicationsClocksFunc mocks the DeviceResetApplicationsClocks method.
	DeviceResetApplicationsClocksFunc func(device nvml.Device) nvml.Return

	// DeviceResetGpuLockedClocksFunc mocks the DeviceResetGpuLockedClocks method.
	DeviceResetGpuLockedClocksFunc func(device nvml.Device) nvml.Return

	// DeviceResetMemoryLockedClocksFunc mocks the DeviceResetMemoryLockedClocks method.
	DeviceResetMemoryLockedClocksFunc func(device nvml.Device) nvml.Return

	// DeviceResetNvLinkErrorCountersFunc mocks the DeviceResetNvLinkErrorCounters method.
	DeviceResetNvLinkErrorCountersFunc func(device nvml.Device, n int) nvml.Return

	// DeviceResetNvLinkUtilizationCounterFunc mocks the DeviceResetNvLinkUtilizationCounter method.
	DeviceResetNvLinkUtilizationCounterFunc func(device nvml.Device, n1 int, n2 int) nvml.Return

	// DeviceSetAPIRestrictionFunc mocks the DeviceSetAPIRestriction method.
	DeviceSetAPIRestrictionFunc func(device nvml.Device, restrictedAPI nvml.RestrictedAPI, enableState nvml.EnableState) nvml.Return

	// DeviceSetAccountingModeFunc mocks the DeviceSetAccountingMode method.
	DeviceSetAccountingModeFunc func(device nvml.Device, enableState nvml.EnableState) nvml.Return

	// DeviceSetApplicationsClocksFunc mocks the DeviceSetApplicationsClocks method.
	DeviceSetApplicationsClocksFunc func(device nvml.Device, v1 uint32, v2 uint32) nvml.Return

	// DeviceSetAutoBoostedClocksEnabledFunc mocks the DeviceSetAutoBoostedClocksEnabled method.
	DeviceSetAutoBoostedClocksEnabledFunc func(device nvml.Device, enableState nvml.EnableState) nvml.Return

	// DeviceSetClockOffsetsFunc mocks the DeviceSetClockOffsets method.
	DeviceSetClockOffsetsFunc func(device nvml.Device, clockOffset nvml.ClockOffset) nvml.Return

	// DeviceSetComputeModeFunc mocks the DeviceSetComputeMode method.
	DeviceSetComputeModeFunc func(device nvml.Device, computeMode nvml.ComputeMode) nvml.Return

	// DeviceSetConfComputeUnprotectedMemSizeFunc mocks the DeviceSetConfComputeUnprotectedMemSize method.
	DeviceSetConfComputeUnprotectedMemSizeFunc func(device nvml.Device, v uint64) nvml.Return

	// DeviceSetCpuAffinityFunc mocks the DeviceSetCpuAffinity method.
	DeviceSetCpuAffinityFunc func(device nvml.Device) nvml.Return

	// DeviceSetDefaultAutoBoostedClocksEnabledFunc mocks the DeviceSetDefaultAutoBoostedClocksEnabled method.
	DeviceSetDefaultAutoBoostedClocksEnabledFunc func(device nvml.Device, enableState nvml.EnableState, v uint32) nvml.Return

	// DeviceSetDefaultFanSpeed_v2Func mocks the DeviceSetDefaultFanSpeed_v2 method.
	DeviceSetDefaultFanSpeed_v2Func func(device nvml.Device, n int) nvml.Return

	// DeviceSetDramEncryptionModeFunc mocks the DeviceSetDramEncryptionMode method.
	DeviceSetDramEncryptionModeFunc func(device nvml.Device, dramEncryptionInfo *nvml.DramEncryptionInfo) nvml.Return

	// DeviceSetDriverModelFunc mocks the DeviceSetDriverModel method.
	DeviceSetDriverModelFunc func(device nvml.Device, driverModel nvml.DriverModel, v uint32) nvml.Return

	// DeviceSetEccModeFunc mocks the DeviceSetEccMode method.
	DeviceSetEccModeFunc func(device nvml.Device, enableState nvml.EnableState) nvml.Return

	// DeviceSetFanControlPolicyFunc mocks the DeviceSetFanControlPolicy method.
	DeviceSetFanControlPolicyFunc func(device nvml.Device, n int, fanControlPolicy nvml.FanControlPolicy) nvml.Return

	// DeviceSetFanSpeed_v2Func mocks the DeviceSetFanSpeed_v2 method.
	DeviceSetFanSpeed_v2Func func(device nvml.Device, n1 int, n2 int) nvml.Return

	// DeviceSetGpcClkVfOffsetFunc mocks the DeviceSetGpcClkVfOffset method.
	DeviceSetGpcClkVfOffsetFunc func(device nvml.Device, n int) nvml.Return

	// DeviceSetGpuLockedClocksFunc mocks the DeviceSetGpuLockedClocks method.
	DeviceSetGpuLockedClocksFunc func(device nvml.Device, v1 uint32, v2 uint32) nvml.Return

	// DeviceSetGpuOperationModeFunc mocks the DeviceSetGpuOperationMode method.
	DeviceSetGpuOperationModeFunc func(device nvml.Device, gpuOperationMode nvml.GpuOperationMode) nvml.Return

	// DeviceSetMemClkVfOffsetFunc mocks the DeviceSetMemClkVfOffset method.
	DeviceSetMemClkVfOffsetFunc func(device nvml.Device, n int) nvml.Return

	// DeviceSetMemoryLockedClocksFunc mocks the DeviceSetMemoryLockedClocks method.
	DeviceSetMemoryLockedClocksFunc func(device nvml.Device, v1 uint32, v2 uint32) nvml.Return

	// DeviceSetMigModeFunc mocks the DeviceSetMigMode method.
	DeviceSetMigModeFunc func(device nvml.Device, n int) (nvml.Return, nvml.Return)

	// DeviceSetNvLinkDeviceLowPowerThresholdFunc mocks the DeviceSetNvLinkDeviceLowPowerThreshold method.
	DeviceSetNvLinkDeviceLowPowerThresholdFunc func(device nvml.Device, nvLinkPowerThres *nvml.NvLinkPowerThres) nvml.Return

	// DeviceSetNvLinkUtilizationControlFunc mocks the DeviceSetNvLinkUtilizationControl method.
	DeviceSetNvLinkUtilizationControlFunc func(device nvml.Device, n1 int, n2 int, nvLinkUtilizationControl *nvml.NvLinkUtilizationControl, b bool) nvml.Return

	// DeviceSetNvlinkBwModeFunc mocks the DeviceSetNvlinkBwMode method.
	DeviceSetNvlinkBwModeFunc func(device nvml.Device, nvlinkSetBwMode *nvml.NvlinkSetBwMode) nvml.Return

	// DeviceSetPersistenceModeFunc mocks the DeviceSetPersistenceMode method.
	DeviceSetPersistenceModeFunc func(device nvml.Device, enableState nvml.EnableState) nvml.Return

	// DeviceSetPowerManagementLimitFunc mocks the DeviceSetPowerManagementLimit method.
	DeviceSetPowerManagementLimitFunc func(device nvml.Device, v uint32) nvml.Return

	// DeviceSetPowerManagementLimit_v2Func mocks the DeviceSetPowerManagementLimit_v2 method.
	DeviceSetPowerManagementLimit_v2Func func(device nvml.Device, powerValue_v2 *nvml.PowerValue_v2) nvml.Return

	// DeviceSetTemperatureThresholdFunc mocks the DeviceSetTemperatureThreshold method.
	DeviceSetTemperatureThresholdFunc func(device nvml.Device, temperatureThresholds nvml.TemperatureThresholds, n int) nvml.Return

	// DeviceSetVgpuCapabilitiesFunc mocks the DeviceSetVgpuCapabilities method.
	DeviceSetVgpuCapabilitiesFunc func(device nvml.Device, deviceVgpuCapability nvml.DeviceVgpuCapability, enableState nvml.EnableState) nvml.Return

	// DeviceSetVgpuHeterogeneousModeFunc mocks the DeviceSetVgpuHeterogeneousMode method.
	DeviceSetVgpuHeterogeneousModeFunc func(device nvml.Device, vgpuHeterogeneousMode nvml.VgpuHeterogeneousMode) nvml.Return

	// DeviceSetVgpuSchedulerStateFunc mocks the DeviceSetVgpuSchedulerState method.
	DeviceSetVgpuSchedulerStateFunc func(device nvml.Device, vgpuSchedulerSetState *nvml.VgpuSchedulerSetState) nvml.Return

	// DeviceSetVirtualizationModeFunc mocks the DeviceSetVirtualizationMode method.
	DeviceSetVirtualizationModeFunc func(device nvml.Device, gpuVirtualizationMode nvml.GpuVirtualizationMode) nvml.Return

	// DeviceValidateInforomFunc mocks the DeviceValidateInforom method.
	DeviceValidateInforomFunc func(device nvml.Device) nvml.Return

	// DeviceWorkloadPowerProfileClearRequestedProfilesFunc mocks the DeviceWorkloadPowerProfileClearRequestedProfiles method.
	DeviceWorkloadPowerProfileClearRequestedProfilesFunc func(device nvml.Device, workloadPowerProfileRequestedProfiles *nvml.WorkloadPowerProfileRequestedProfiles) nvml.Return

	// DeviceWorkloadPowerProfileGetCurrentProfilesFunc mocks the DeviceWorkloadPowerProfileGetCurrentProfiles method.
	DeviceWorkloadPowerProfileGetCurrentProfilesFunc func(device nvml.Device) (nvml.WorkloadPowerProfileCurrentProfiles, nvml.Return)

	// DeviceWorkloadPowerProfileGetProfilesInfoFunc mocks the DeviceWorkloadPowerProfileGetProfilesInfo method.
	DeviceWorkloadPowerProfileGetProfilesInfoFunc func(device nvml.Device) (nvml.WorkloadPowerProfileProfilesInfo, nvml.Return)

	// DeviceWorkloadPowerProfileSetRequestedProfilesFunc mocks the DeviceWorkloadPowerProfileSetRequestedProfiles method.
	DeviceWorkloadPowerProfileSetRequestedProfilesFunc func(device nvml.Device, workloadPowerProfileRequestedProfiles *nvml.WorkloadPowerProfileRequestedProfiles) nvml.Return

	// ErrorStringFunc mocks the ErrorString method.
	ErrorStringFunc func(returnMoqParam nvml.Return) string

	// EventSetCreateFunc mocks the EventSetCreate method.
	EventSetCreateFunc func() (nvml.EventSet, nvml.Return)

	// EventSetFreeFunc mocks the EventSetFree method.
	EventSetFreeFunc func(eventSet nvml.EventSet) nvml.Return

	// EventSetWaitFunc mocks the EventSetWait method.
	EventSetWaitFunc func(eventSet nvml.EventSet, v uint32) (nvml.EventData, nvml.Return)

	// ExtensionsFunc mocks the Extensions method.
	ExtensionsFunc func() nvml.ExtendedInterface

	// GetExcludedDeviceCountFunc mocks the GetExcludedDeviceCount method.
	GetExcludedDeviceCountFunc func() (int, nvml.Return)

	// GetExcludedDeviceInfoByIndexFunc mocks the GetExcludedDeviceInfoByIndex method.
	GetExcludedDeviceInfoByIndexFunc func(n int) (nvml.ExcludedDeviceInfo, nvml.Return)

	// GetVgpuCompatibilityFunc mocks the GetVgpuCompatibility method.
	GetVgpuCompatibilityFunc func(vgpuMetadata *nvml.VgpuMetadata, vgpuPgpuMetadata *nvml.VgpuPgpuMetadata) (nvml.VgpuPgpuCompatibility, nvml.Return)

	// GetVgpuDriverCapabilitiesFunc mocks the GetVgpuDriverCapabilities method.
	GetVgpuDriverCapabilitiesFunc func(vgpuDriverCapability nvml.VgpuDriverCapability) (bool, nvml.Return)

	// GetVgpuVersionFunc mocks the GetVgpuVersion method.
	GetVgpuVersionFunc func() (nvml.VgpuVersion, nvml.VgpuVersion, nvml.Return)

	// GpmMetricsGetFunc mocks the GpmMetricsGet method.
	GpmMetricsGetFunc func(gpmMetricsGetType *nvml.GpmMetricsGetType) nvml.Return

	// GpmMetricsGetVFunc mocks the GpmMetricsGetV method.
	GpmMetricsGetVFunc func(gpmMetricsGetType *nvml.GpmMetricsGetType) nvml.GpmMetricsGetVType

	// GpmMigSampleGetFunc mocks the GpmMigSampleGet method.
	GpmMigSampleGetFunc func(device nvml.Device, n int, gpmSample nvml.GpmSample) nvml.Return

	// GpmQueryDeviceSupportFunc mocks the GpmQueryDeviceSupport method.
	GpmQueryDeviceSupportFunc func(device nvml.Device) (nvml.GpmSupport, nvml.Return)

	// GpmQueryDeviceSupportVFunc mocks the GpmQueryDeviceSupportV method.
	GpmQueryDeviceSupportVFunc func(device nvml.Device) nvml.GpmSupportV

	// GpmQueryIfStreamingEnabledFunc mocks the GpmQueryIfStreamingEnabled method.
	GpmQueryIfStreamingEnabledFunc func(device nvml.Device) (uint32, nvml.Return)

	// GpmSampleAllocFunc mocks the GpmSampleAlloc method.
	GpmSampleAllocFunc func() (nvml.GpmSample, nvml.Return)

	// GpmSampleFreeFunc mocks the GpmSampleFree method.
	GpmSampleFreeFunc func(gpmSample nvml.GpmSample) nvml.Return

	// GpmSampleGetFunc mocks the GpmSampleGet method.
	GpmSampleGetFunc func(device nvml.Device, gpmSample nvml.GpmSample) nvml.Return

	// GpmSetStreamingEnabledFunc mocks the GpmSetStreamingEnabled method.
	GpmSetStreamingEnabledFunc func(device nvml.Device, v uint32) nvml.Return

	// GpuInstanceCreateComputeInstanceFunc mocks the GpuInstanceCreateComputeInstance method.
	GpuInstanceCreateComputeInstanceFunc func(gpuInstance nvml.GpuInstance, computeInstanceProfileInfo *nvml.ComputeInstanceProfileInfo) (nvml.ComputeInstance, nvml.Return)

	// GpuInstanceCreateComputeInstanceWithPlacementFunc mocks the GpuInstanceCreateComputeInstanceWithPlacement method.
	GpuInstanceCreateComputeInstanceWithPlacementFunc func(gpuInstance nvml.GpuInstance, computeInstanceProfileInfo *nvml.ComputeInstanceProfileInfo, computeInstancePlacement *nvml.ComputeInstancePlacement) (nvml.ComputeInstance, nvml.Return)

	// GpuInstanceDestroyFunc mocks the GpuInstanceDestroy method.
	GpuInstanceDestroyFunc func(gpuInstance nvml.GpuInstance) nvml.Return

	// GpuInstanceGetActiveVgpusFunc mocks the GpuInstanceGetActiveVgpus method.
	GpuInstanceGetActiveVgpusFunc func(gpuInstance nvml.GpuInstance) (nvml.ActiveVgpuInstanceInfo, nvml.Return)

	// GpuInstanceGetComputeInstanceByIdFunc mocks the GpuInstanceGetComputeInstanceById method.
	GpuInstanceGetComputeInstanceByIdFunc func(gpuInstance nvml.GpuInstance, n int) (nvml.ComputeInstance, nvml.Return)

	// GpuInstanceGetComputeInstancePossiblePlacementsFunc mocks the GpuInstanceGetComputeInstancePossiblePlacements method.
	GpuInstanceGetComputeInstancePossiblePlacementsFunc func(gpuInstance nvml.GpuInstance, computeInstanceProfileInfo *nvml.ComputeInstanceProfileInfo) ([]nvml.ComputeInstancePlacement, nvml.Return)

	// GpuInstanceGetComputeInstanceProfileInfoFunc mocks the GpuInstanceGetComputeInstanceProfileInfo method.
	GpuInstanceGetComputeInstanceProfileInfoFunc func(gpuInstance nvml.GpuInstance, n1 int, n2 int) (nvml.ComputeInstanceProfileInfo, nvml.Return)

	// GpuInstanceGetComputeInstanceProfileInfoVFunc mocks the GpuInstanceGetComputeInstanceProfileInfoV method.
	GpuInstanceGetComputeInstanceProfileInfoVFunc func(gpuInstance nvml.GpuInstance, n1 int, n2 int) nvml.ComputeInstanceProfileInfoHandler

	// GpuInstanceGetComputeInstanceRemainingCapacityFunc mocks the GpuInstanceGetComputeInstanceRemainingCapacity method.
	GpuInstanceGetComputeInstanceRemainingCapacityFunc func(gpuInstance nvml.GpuInstance, computeInstanceProfileInfo *nvml.ComputeInstanceProfileInfo) (int, nvml.Return)

	// GpuInstanceGetComputeInstancesFunc mocks the GpuInstanceGetComputeInstances method.
	GpuInstanceGetComputeInstancesFunc func(gpuInstance nvml.GpuInstance, computeInstanceProfileInfo *nvml.ComputeInstanceProfileInfo) ([]nvml.ComputeInstance, nvml.Return)

	// GpuInstanceGetCreatableVgpusFunc mocks the GpuInstanceGetCreatableVgpus method.
	GpuInstanceGetCreatableVgpusFunc func(gpuInstance nvml.GpuInstance) (nvml.VgpuTypeIdInfo, nvml.Return)

	// GpuInstanceGetInfoFunc mocks the GpuInstanceGetInfo method.
	GpuInstanceGetInfoFunc func(gpuInstance nvml.GpuInstance) (nvml.GpuInstanceInfo, nvml.Return)

	// GpuInstanceGetVgpuHeterogeneousModeFunc mocks the GpuInstanceGetVgpuHeterogeneousMode method.
	GpuInstanceGetVgpuHeterogeneousModeFunc func(gpuInstance nvml.GpuInstance) (nvml.VgpuHeterogeneousMode, nvml.Return)

	// GpuInstanceGetVgpuSchedulerLogFunc mocks the GpuInstanceGetVgpuSchedulerLog method.
	GpuInstanceGetVgpuSchedulerLogFunc func(gpuInstance nvml.GpuInstance) (nvml.VgpuSchedulerLogInfo, nvml.Return)

	// GpuInstanceGetVgpuSchedulerStateFunc mocks the GpuInstanceGetVgpuSchedulerState method.
	GpuInstanceGetVgpuSchedulerStateFunc func(gpuInstance nvml.GpuInstance) (nvml.VgpuSchedulerStateInfo, nvml.Return)

	// GpuInstanceGetVgpuTypeCreatablePlacementsFunc mocks the GpuInstanceGetVgpuTypeCreatablePlacements method.
	GpuInstanceGetVgpuTypeCreatablePlacementsFunc func(gpuInstance nvml.GpuInstance) (nvml.VgpuCreatablePlacementInfo, nvml.Return)

	// GpuInstanceSetVgpuHeterogeneousModeFunc mocks the GpuInstanceSetVgpuHeterogeneousMode method.
	GpuInstanceSetVgpuHeterogeneousModeFunc func(gpuInstance nvml.GpuInstance, vgpuHeterogeneousMode *nvml.VgpuHeterogeneousMode) nvml.Return

	// GpuInstanceSetVgpuSchedulerStateFunc mocks the GpuInstanceSetVgpuSchedulerState method.
	GpuInstanceSetVgpuSchedulerStateFunc func(gpuInstance nvml.GpuInstance, vgpuSchedulerState *nvml.VgpuSchedulerState) nvml.Return

	// InitFunc mocks the Init method.
	InitFunc func() nvml.Return

	// InitWithFlagsFunc mocks the InitWithFlags method.
	InitWithFlagsFunc func(v uint32) nvml.Return

	// SetVgpuVersionFunc mocks the SetVgpuVersion method.
	SetVgpuVersionFunc func(vgpuVersion *nvml.VgpuVersion) nvml.Return

	// ShutdownFunc mocks the Shutdown method.
	ShutdownFunc func() nvml.Return

	// SystemEventSetCreateFunc mocks the SystemEventSetCreate method.
	SystemEventSetCreateFunc func(systemEventSetCreateRequest *nvml.SystemEventSetCreateRequest) nvml.Return

	// SystemEventSetFreeFunc mocks the SystemEventSetFree method.
	SystemEventSetFreeFunc func(systemEventSetFreeRequest *nvml.SystemEventSetFreeRequest) nvml.Return

	// SystemEventSetWaitFunc mocks the SystemEventSetWait method.
	SystemEventSetWaitFunc func(systemEventSetWaitRequest *nvml.SystemEventSetWaitRequest) nvml.Return

	// SystemGetConfComputeCapabilitiesFunc mocks the SystemGetConfComputeCapabilities method.
	SystemGetConfComputeCapabilitiesFunc func() (nvml.ConfComputeSystemCaps, nvml.Return)

	// SystemGetConfComputeGpusReadyStateFunc mocks the SystemGetConfComputeGpusReadyState method.
	SystemGetConfComputeGpusReadyStateFunc func() (uint32, nvml.Return)

	// SystemGetConfComputeKeyRotationThresholdInfoFunc mocks the SystemGetConfComputeKeyRotationThresholdInfo method.
	SystemGetConfComputeKeyRotationThresholdInfoFunc func() (nvml.ConfComputeGetKeyRotationThresholdInfo, nvml.Return)

	// SystemGetConfComputeSettingsFunc mocks the SystemGetConfComputeSettings method.
	SystemGetConfComputeSettingsFunc func() (nvml.SystemConfComputeSettings, nvml.Return)

	// SystemGetConfComputeStateFunc mocks the SystemGetConfComputeState method.
	SystemGetConfComputeStateFunc func() (nvml.ConfComputeSystemState, nvml.Return)

	// SystemGetCudaDriverVersionFunc mocks the SystemGetCudaDriverVersion method.
	SystemGetCudaDriverVersionFunc func() (int, nvml.Return)

	// SystemGetCudaDriverVersion_v2Func mocks the SystemGetCudaDriverVersion_v2 method.
	SystemGetCudaDriverVersion_v2Func func() (int, nvml.Return)

	// SystemGetDriverBranchFunc mocks the SystemGetDriverBranch method.
	SystemGetDriverBranchFunc func() (nvml.SystemDriverBranchInfo, nvml.Return)

	// SystemGetDriverVersionFunc mocks the SystemGetDriverVersion method.
	SystemGetDriverVersionFunc func() (string, nvml.Return)

	// SystemGetHicVersionFunc mocks the SystemGetHicVersion method.
	SystemGetHicVersionFunc func() ([]nvml.HwbcEntry, nvml.Return)

	// SystemGetNVMLVersionFunc mocks the SystemGetNVMLVersion method.
	SystemGetNVMLVersionFunc func() (string, nvml.Return)

	// SystemGetNvlinkBwModeFunc mocks the SystemGetNvlinkBwMode method.
	SystemGetNvlinkBwModeFunc func() (uint32, nvml.Return)

	// SystemGetProcessNameFunc mocks the SystemGetProcessName method.
	SystemGetProcessNameFunc func(n int) (string, nvml.Return)

	// SystemGetTopologyGpuSetFunc mocks the SystemGetTopologyGpuSet method.
	SystemGetTopologyGpuSetFunc func(n int) ([]nvml.Device, nvml.Return)

	// SystemRegisterEventsFunc mocks the SystemRegisterEvents method.
	SystemRegisterEventsFunc func(systemRegisterEventRequest *nvml.SystemRegisterEventRequest) nvml.Return

	// SystemSetConfComputeGpusReadyStateFunc mocks the SystemSetConfComputeGpusReadyState method.
	SystemSetConfComputeGpusReadyStateFunc func(v uint32) nvml.Return

	// SystemSetConfComputeKeyRotationThresholdInfoFunc mocks the SystemSetConfComputeKeyRotationThresholdInfo method.
	SystemSetConfComputeKeyRotationThresholdInfoFunc func(confComputeSetKeyRotationThresholdInfo nvml.ConfComputeSetKeyRotationThresholdInfo) nvml.Return

	// SystemSetNvlinkBwModeFunc mocks the SystemSetNvlinkBwMode method.
	SystemSetNvlinkBwModeFunc func(v uint32) nvml.Return

	// UnitGetCountFunc mocks the UnitGetCount method.
	UnitGetCountFunc func() (int, nvml.Return)

	// UnitGetDevicesFunc mocks the UnitGetDevices method.
	UnitGetDevicesFunc func(unit nvml.Unit) ([]nvml.Device, nvml.Return)

	// UnitGetFanSpeedInfoFunc mocks the UnitGetFanSpeedInfo method.
	UnitGetFanSpeedInfoFunc func(unit nvml.Unit) (nvml.UnitFanSpeeds, nvml.Return)

	// UnitGetHandleByIndexFunc mocks the UnitGetHandleByIndex method.
	UnitGetHandleByIndexFunc func(n int) (nvml.Unit, nvml.Return)

	// UnitGetLedStateFunc mocks the UnitGetLedState method.
	UnitGetLedStateFunc func(unit nvml.Unit) (nvml.LedState, nvml.Return)

	// UnitGetPsuInfoFunc mocks the UnitGetPsuInfo method.
	UnitGetPsuInfoFunc func(unit nvml.Unit) (nvml.PSUInfo, nvml.Return)

	// UnitGetTemperatureFunc mocks the UnitGetTemperature method.
	UnitGetTemperatureFunc func(unit nvml.Unit, n int) (uint32, nvml.Return)

	// UnitGetUnitInfoFunc mocks the UnitGetUnitInfo method.
	UnitGetUnitInfoFunc func(unit nvml.Unit) (nvml.UnitInfo, nvml.Return)

	// UnitSetLedStateFunc mocks the UnitSetLedState method.
	UnitSetLedStateFunc func(unit nvml.Unit, ledColor nvml.LedColor) nvml.Return

	// VgpuInstanceClearAccountingPidsFunc mocks the VgpuInstanceClearAccountingPids method.
	VgpuInstanceClearAccountingPidsFunc func(vgpuInstance nvml.VgpuInstance) nvml.Return

	// VgpuInstanceGetAccountingModeFunc mocks the VgpuInstanceGetAccountingMode method.
	VgpuInstanceGetAccountingModeFunc func(vgpuInstance nvml.VgpuInstance) (nvml.EnableState, nvml.Return)

	// VgpuInstanceGetAccountingPidsFunc mocks the VgpuInstanceGetAccountingPids method.
	VgpuInstanceGetAccountingPidsFunc func(vgpuInstance nvml.VgpuInstance) ([]int, nvml.Return)

	// VgpuInstanceGetAccountingStatsFunc mocks the VgpuInstanceGetAccountingStats method.
	VgpuInstanceGetAccountingStatsFunc func(vgpuInstance nvml.VgpuInstance, n int) (nvml.AccountingStats, nvml.Return)

	// VgpuInstanceGetEccModeFunc mocks the VgpuInstanceGetEccMode method.
	VgpuInstanceGetEccModeFunc func(vgpuInstance nvml.VgpuInstance) (nvml.EnableState, nvml.Return)

	// VgpuInstanceGetEncoderCapacityFunc mocks the VgpuInstanceGetEncoderCapacity method.
	VgpuInstanceGetEncoderCapacityFunc func(vgpuInstance nvml.VgpuInstance) (int, nvml.Return)

	// VgpuInstanceGetEncoderSessionsFunc mocks the VgpuInstanceGetEncoderSessions method.
	VgpuInstanceGetEncoderSessionsFunc func(vgpuInstance nvml.VgpuInstance) (int, nvml.EncoderSessionInfo, nvml.Return)

	// VgpuInstanceGetEncoderStatsFunc mocks the VgpuInstanceGetEncoderStats method.
	VgpuInstanceGetEncoderStatsFunc func(vgpuInstance nvml.VgpuInstance) (int, uint32, uint32, nvml.Return)

	// VgpuInstanceGetFBCSessionsFunc mocks the VgpuInstanceGetFBCSessions method.
	VgpuInstanceGetFBCSessionsFunc func(vgpuInstance nvml.VgpuInstance) (int, nvml.FBCSessionInfo, nvml.Return)

	// VgpuInstanceGetFBCStatsFunc mocks the VgpuInstanceGetFBCStats method.
	VgpuInstanceGetFBCStatsFunc func(vgpuInstance nvml.VgpuInstance) (nvml.FBCStats, nvml.Return)

	// VgpuInstanceGetFbUsageFunc mocks the VgpuInstanceGetFbUsage method.
	VgpuInstanceGetFbUsageFunc func(vgpuInstance nvml.VgpuInstance) (uint64, nvml.Return)

	// VgpuInstanceGetFrameRateLimitFunc mocks the VgpuInstanceGetFrameRateLimit method.
	VgpuInstanceGetFrameRateLimitFunc func(vgpuInstance nvml.VgpuInstance) (uint32, nvml.Return)

	// VgpuInstanceGetGpuInstanceIdFunc mocks the VgpuInstanceGetGpuInstanceId method.
	VgpuInstanceGetGpuInstanceIdFunc func(vgpuInstance nvml.VgpuInstance) (int, nvml.Return)

	// VgpuInstanceGetGpuPciIdFunc mocks the VgpuInstanceGetGpuPciId method.
	VgpuInstanceGetGpuPciIdFunc func(vgpuInstance nvml.VgpuInstance) (string, nvml.Return)

	// VgpuInstanceGetLicenseInfoFunc mocks the VgpuInstanceGetLicenseInfo method.
	VgpuInstanceGetLicenseInfoFunc func(vgpuInstance nvml.VgpuInstance) (nvml.VgpuLicenseInfo, nvml.Return)

	// VgpuInstanceGetLicenseStatusFunc mocks the VgpuInstanceGetLicenseStatus method.
	VgpuInstanceGetLicenseStatusFunc func(vgpuInstance nvml.VgpuInstance) (int, nvml.Return)

	// VgpuInstanceGetMdevUUIDFunc mocks the VgpuInstanceGetMdevUUID method.
	VgpuInstanceGetMdevUUIDFunc func(vgpuInstance nvml.VgpuInstance) (string, nvml.Return)

	// VgpuInstanceGetMetadataFunc mocks the VgpuInstanceGetMetadata method.
	VgpuInstanceGetMetadataFunc func(vgpuInstance nvml.VgpuInstance) (nvml.VgpuMetadata, nvml.Return)

	// VgpuInstanceGetRuntimeStateSizeFunc mocks the VgpuInstanceGetRuntimeStateSize method.
	VgpuInstanceGetRuntimeStateSizeFunc func(vgpuInstance nvml.VgpuInstance) (nvml.VgpuRuntimeState, nvml.Return)

	// VgpuInstanceGetTypeFunc mocks the VgpuInstanceGetType method.
	VgpuInstanceGetTypeFunc func(vgpuInstance nvml.VgpuInstance) (nvml.VgpuTypeId, nvml.Return)

	// VgpuInstanceGetUUIDFunc mocks the VgpuInstanceGetUUID method.
	VgpuInstanceGetUUIDFunc func(vgpuInstance nvml.VgpuInstance) (string, nvml.Return)

	// VgpuInstanceGetVmDriverVersionFunc mocks the VgpuInstanceGetVmDriverVersion method.
	VgpuInstanceGetVmDriverVersionFunc func(vgpuInstance nvml.VgpuInstance) (string, nvml.Return)

	// VgpuInstanceGetVmIDFunc mocks the VgpuInstanceGetVmID method.
	VgpuInstanceGetVmIDFunc func(vgpuInstance nvml.VgpuInstance) (string, nvml.VgpuVmIdType, nvml.Return)

	// VgpuInstanceSetEncoderCapacityFunc mocks the VgpuInstanceSetEncoderCapacity method.
	VgpuInstanceSetEncoderCapacityFunc func(vgpuInstance nvml.VgpuInstance, n int) nvml.Return

	// VgpuTypeGetBAR1InfoFunc mocks the VgpuTypeGetBAR1Info method.
	VgpuTypeGetBAR1InfoFunc func(vgpuTypeId nvml.VgpuTypeId) (nvml.VgpuTypeBar1Info, nvml.Return)

	// VgpuTypeGetCapabilitiesFunc mocks the VgpuTypeGetCapabilities method.
	VgpuTypeGetCapabilitiesFunc func(vgpuTypeId nvml.VgpuTypeId, vgpuCapability nvml.VgpuCapability) (bool, nvml.Return)

	// VgpuTypeGetClassFunc mocks the VgpuTypeGetClass method.
	VgpuTypeGetClassFunc func(vgpuTypeId nvml.VgpuTypeId) (string, nvml.Return)

	// VgpuTypeGetDeviceIDFunc mocks the VgpuTypeGetDeviceID method.
	VgpuTypeGetDeviceIDFunc func(vgpuTypeId nvml.VgpuTypeId) (uint64, uint64, nvml.Return)

	// VgpuTypeGetFrameRateLimitFunc mocks the VgpuTypeGetFrameRateLimit method.
	VgpuTypeGetFrameRateLimitFunc func(vgpuTypeId nvml.VgpuTypeId) (uint32, nvml.Return)

	// VgpuTypeGetFramebufferSizeFunc mocks the VgpuTypeGetFramebufferSize method.
	VgpuTypeGetFramebufferSizeFunc func(vgpuTypeId nvml.VgpuTypeId) (uint64, nvml.Return)

	// VgpuTypeGetGpuInstanceProfileIdFunc mocks the VgpuTypeGetGpuInstanceProfileId method.
	VgpuTypeGetGpuInstanceProfileIdFunc func(vgpuTypeId nvml.VgpuTypeId) (uint32, nvml.Return)

	// VgpuTypeGetLicenseFunc mocks the VgpuTypeGetLicense method.
	VgpuTypeGetLicenseFunc func(vgpuTypeId nvml.VgpuTypeId) (string, nvml.Return)

	// VgpuTypeGetMaxInstancesFunc mocks the VgpuTypeGetMaxInstances method.
	VgpuTypeGetMaxInstancesFunc func(device nvml.Device, vgpuTypeId nvml.VgpuTypeId) (int, nvml.Return)

	// VgpuTypeGetMaxInstancesPerGpuInstanceFunc mocks the VgpuTypeGetMaxInstancesPerGpuInstance method.
	VgpuTypeGetMaxInstancesPerGpuInstanceFunc func(vgpuTypeMaxInstance *nvml.VgpuTypeMaxInstance) nvml.Return

	// VgpuTypeGetMaxInstancesPerVmFunc mocks the VgpuTypeGetMaxInstancesPerVm method.
	VgpuTypeGetMaxInstancesPerVmFunc func(vgpuTypeId nvml.VgpuTypeId) (int, nvml.Return)

	// VgpuTypeGetNameFunc mocks the VgpuTypeGetName method.
	VgpuTypeGetNameFunc func(vgpuTypeId nvml.VgpuTypeId) (string, nvml.Return)

	// VgpuTypeGetNumDisplayHeadsFunc mocks the VgpuTypeGetNumDisplayHeads method.
	VgpuTypeGetNumDisplayHeadsFunc func(vgpuTypeId nvml.VgpuTypeId) (int, nvml.Return)

	// VgpuTypeGetResolutionFunc mocks the VgpuTypeGetResolution method.
	VgpuTypeGetResolutionFunc func(vgpuTypeId nvml.VgpuTypeId, n int) (uint32, uint32, nvml.Return)

	// calls tracks calls to the methods.
	calls struct {
		// ComputeInstanceDestroy holds details about calls to the ComputeInstanceDestroy method.
		ComputeInstanceDestroy []struct {
			// ComputeInstance is the computeInstance argument value.
			ComputeInstance nvml.ComputeInstance
		}
		// ComputeInstanceGetInfo holds details about calls to the ComputeInstanceGetInfo method.
		ComputeInstanceGetInfo []struct {
			// ComputeInstance is the computeInstance argument value.
			ComputeInstance nvml.ComputeInstance
		}
		// DeviceClearAccountingPids holds details about calls to the DeviceClearAccountingPids method.
		DeviceClearAccountingPids []struct {
			// Device is the device argument value.
			Device nvml.Device
		}
		// DeviceClearCpuAffinity holds details about calls to the DeviceClearCpuAffinity method.
		DeviceClearCpuAffinity []struct {
			// Device is the device argument value.
			Device nvml.Device
		}
		// DeviceClearEccErrorCounts holds details about calls to the DeviceClearEccErrorCounts method.
		DeviceClearEccErrorCounts []struct {
			// Device is the device argument value.
			Device nvml.Device
			// EccCounterType is the eccCounterType argument value.
			EccCounterType nvml.EccCounterType
		}
		// DeviceClearFieldValues holds details about calls to the DeviceClearFieldValues method.
		DeviceClearFieldValues []struct {
			// Device is the device argument value.
			Device nvml.Device
			// FieldValues is the fieldValues argument value.
			FieldValues []nvml.FieldValue
		}
		// DeviceCreateGpuInstance holds details about calls to the DeviceCreateGpuInstance method.
		DeviceCreateGpuInstance []struct {
			// Device is the device argument value.
			Device nvml.Device
			// GpuInstanceProfileInfo is the gpuInstanceProfileInfo argument value.
			GpuInstanceProfileInfo *nvml.GpuInstanceProfileInfo
		}
		// DeviceCreateGpuInstanceWithPlacement holds details about calls to the DeviceCreateGpuInstanceWithPlacement method.
		DeviceCreateGpuInstanceWithPlacement []struct {
			// Device is the device argument value.
			Device nvml.Device
			// GpuInstanceProfileInfo is the gpuInstanceProfileInfo argument value.
			GpuInstanceProfileInfo *nvml.GpuInstanceProfileInfo
			// GpuInstancePlacement is the gpuInstancePlacement argument value.
			GpuInstancePlacement *nvml.GpuInstancePlacement
		}
		// DeviceDiscoverGpus holds details about calls to the DeviceDiscoverGpus method.
		DeviceDiscoverGpus []struct {
		}
		// DeviceFreezeNvLinkUtilizationCounter holds details about calls to the DeviceFreezeNvLinkUtilizationCounter method.
		DeviceFreezeNvLinkUtilizationCounter []struct {
			// Device is the device argument value.
			Device nvml.Device
			// N1 is the n1 argument value.
			N1 int
			// N2 is the n2 argument value.
			N2 int
			// EnableState is the enableState argument value.
			EnableState nvml.EnableState
		}
		// DeviceGetAPIRestriction holds details about calls to the DeviceGetAPIRestriction method.
		DeviceGetAPIRestriction []struct {
			// Device is the device argument value.
			Device nvml.Device
			// RestrictedAPI is the restrictedAPI argument value.
			RestrictedAPI nvml.RestrictedAPI
		}
		// DeviceGetAccountingBufferSize holds details about calls to the DeviceGetAccountingBufferSize method.
		DeviceGetAccountingBufferSize []struct {
			// Device is the device argument value.
			Device nvml.Device
		}
		// DeviceGetAccountingMode holds details about calls to the DeviceGetAccountingMode method.
		DeviceGetAccountingMode []struct {
			// Device is the device argument value.
			Device nvml.Device
		}
		// DeviceGetAccountingPids holds details about calls to the DeviceGetAccountingPids method.
		DeviceGetAccountingPids []struct {
			// Device is the device argument value.
			Device nvml.Device
		}
		// DeviceGetAccountingStats holds details about calls to the DeviceGetAccountingStats method.
		DeviceGetAccountingStats []struct {
			// Device is the device argument value.
			Device nvml.Device
			// V is the v argument value.
			V uint32
		}
		// DeviceGetActiveVgpus holds details about calls to the DeviceGetActiveVgpus method.
		DeviceGetActiveVgpus []struct {
			// Device is the device argument value.
			Device nvml.Device
		}
		// DeviceGetAdaptiveClockInfoStatus holds details about calls to the DeviceGetAdaptiveClockInfoStatus method.
		DeviceGetAdaptiveClockInfoStatus []struct {
			// Device is the device argument value.
			Device nvml.Device
		}
		// DeviceGetAddressingMode holds details about calls to the DeviceGetAddressingMode method.
		DeviceGetAddressingMode []struct {
			// Device is the device argument value.
			Device nvml.Device
		}
		// DeviceGetApplicationsClock holds details about calls to the DeviceGetApplicationsClock method.
		DeviceGetApplicationsClock []struct {
			// Device is the device argument value.
			Device nvml.Device
			// ClockType is the clockType argument value.
			ClockType nvml.ClockType
		}
		// DeviceGetArchitecture holds details about calls to the DeviceGetArchitecture method.
		DeviceGetArchitecture []struct {
			// Device is the device argument value.
			Device nvml.Device
		}
		// DeviceGetAttributes holds details about calls to the DeviceGetAttributes method.
		DeviceGetAttributes []struct {
			// Device is the device argument value.
			Device nvml.Device
		}
		// DeviceGetAutoBoostedClocksEnabled holds details about calls to the DeviceGetAutoBoostedClocksEnabled method.
		DeviceGetAutoBoostedClocksEnabled []struct {
			// Device is the device argument value.
			Device nvml.Device
		}
		// DeviceGetBAR1MemoryInfo holds details about calls to the DeviceGetBAR1MemoryInfo method.
		DeviceGetBAR1MemoryInfo []struct {
			// Device is the device argument value.
			Device nvml.Device
		}
		// DeviceGetBoardId holds details about calls to the DeviceGetBoardId method.
		DeviceGetBoardId []struct {
			// Device is the device argument value.
			Device nvml.Device
		}
		// DeviceGetBoardPartNumber holds details about calls to the DeviceGetBoardPartNumber method.
		DeviceGetBoardPartNumber []struct {
			// Device is the device argument value.
			Device nvml.Device
		}
		// DeviceGetBrand holds details about calls to the DeviceGetBrand method.
		DeviceGetBrand []struct {
			// Device is the device argument value.
			Device nvml.Device
		}
		// DeviceGetBridgeChipInfo holds details about calls to the DeviceGetBridgeChipInfo method.
		DeviceGetBridgeChipInfo []struct {
			// Device is the device argument value.
			Device nvml.Device
		}
		// DeviceGetBusType holds details about calls to the DeviceGetBusType method.
		DeviceGetBusType []struct {
			// Device is the device argument value.
			Device nvml.Device
		}
		// DeviceGetC2cModeInfoV holds details about calls to the DeviceGetC2cModeInfoV method.
		DeviceGetC2cModeInfoV []struct {
			// Device is the device argument value.
			Device nvml.Device
		}
		// DeviceGetCapabilities holds details about calls to the DeviceGetCapabilities method.
		DeviceGetCapabilities []struct {
			// Device is the device argument value.
			Device nvml.Device
		}
		// DeviceGetClkMonStatus holds details about calls to the DeviceGetClkMonStatus method.
		DeviceGetClkMonStatus []struct {
			// Device is the device argument value.
			Device nvml.Device
		}
		// DeviceGetClock holds details about calls to the DeviceGetClock method.
		DeviceGetClock []struct {
			// Device is the device argument value.
			Device nvml.Device
			// ClockType is the clockType argument value.
			ClockType nvml.ClockType
			// ClockId is the clockId argument value.
			ClockId nvml.ClockId
		}
		// DeviceGetClockInfo holds details about calls to the DeviceGetClockInfo method.
		DeviceGetClockInfo []struct {
			// Device is the device argument value.
			Device nvml.Device
			// ClockType is the clockType argument value.
			ClockType nvml.ClockType
		}
		// DeviceGetClockOffsets holds details about calls to the DeviceGetClockOffsets method.
		DeviceGetClockOffsets []struct {
			// Device is the device argument value.
			Device nvml.Device
		}
		// DeviceGetComputeInstanceId holds details about calls to the DeviceGetComputeInstanceId method.
		DeviceGetComputeInstanceId []struct {
			// Device is the device argument value.
			Device nvml.Device
		}
		// DeviceGetComputeMode holds details about calls to the DeviceGetComputeMode method.
		DeviceGetComputeMode []struct {
			// Device is the device argument value.
			Device nvml.Device
		}
		// DeviceGetComputeRunningProcesses holds details about calls to the DeviceGetComputeRunningProcesses method.
		DeviceGetComputeRunningProcesses []struct {
			// Device is the device argument value.
			Device nvml.Device
		}
		// DeviceGetConfComputeGpuAttestationReport holds details about calls to the DeviceGetConfComputeGpuAttestationReport method.
		DeviceGetConfComputeGpuAttestationReport []struct {
			// Device is the device argument value.
			Device nvml.Device
			// ConfComputeGpuAttestationReport is the confComputeGpuAttestationReport argument value.
			ConfComputeGpuAttestationReport *nvml.ConfComputeGpuAttestationReport
		}
		// DeviceGetConfComputeGpuCertificate holds details about calls to the DeviceGetConfComputeGpuCertificate method.
		DeviceGetConfComputeGpuCertificate []struct {
			// Device is the device argument value.
			Device nvml.Device
		}
		// DeviceGetConfComputeMemSizeInfo holds details about calls to the DeviceGetConfComputeMemSizeInfo method.
		DeviceGetConfComputeMemSizeInfo []struct {
			// Device is the device argument value.
			Device nvml.Device
		}
		// DeviceGetConfComputeProtectedMemoryUsage holds details about calls to the DeviceGetConfComputeProtectedMemoryUsage method.
		DeviceGetConfComputeProtectedMemoryUsage []struct {
			// Device is the device argument value.
			Device nvml.Device
		}
		// DeviceGetCoolerInfo holds details about calls to the DeviceGetCoolerInfo method.
		DeviceGetCoolerInfo []struct {
			// Device is the device argument value.
			Device nvml.Device
		}
		// DeviceGetCount holds details about calls to the DeviceGetCount method.
		DeviceGetCount []struct {
		}
		// DeviceGetCpuAffinity holds details about calls to the DeviceGetCpuAffinity method.
		DeviceGetCpuAffinity []struct {
			// Device is the device argument value.
			Device nvml.Device
			// N is the n argument value.
			N int
		}
		// DeviceGetCpuAffinityWithinScope holds details about calls to the DeviceGetCpuAffinityWithinScope method.
		DeviceGetCpuAffinityWithinScope []struct {
			// Device is the device argument value.
			Device nvml.Device
			// N is the n argument value.
			N int
			// AffinityScope is the affinityScope argument value.
			AffinityScope nvml.AffinityScope
		}
		// DeviceGetCreatableVgpus holds details about calls to the DeviceGetCreatableVgpus method.
		DeviceGetCreatableVgpus []struct {
			// Device is the device argument value.
			Device nvml.Device
		}
		// DeviceGetCudaComputeCapability holds details about calls to the DeviceGetCudaComputeCapability method.
		DeviceGetCudaComputeCapability []struct {
			// Device is the device argument value.
			Device nvml.Device
		}
		// DeviceGetCurrPcieLinkGeneration holds details about calls to the DeviceGetCurrPcieLinkGeneration method.
		DeviceGetCurrPcieLinkGeneration []struct {
			// Device is the device argument value.
			Device nvml.Device
		}
		// DeviceGetCurrPcieLinkWidth holds details about calls to the DeviceGetCurrPcieLinkWidth method.
		DeviceGetCurrPcieLinkWidth []struct {
			// Device is the device argument value.
			Device nvml.Device
		}
		// DeviceGetCurrentClockFreqs holds details about calls to the DeviceGetCurrentClockFreqs method.
		DeviceGetCurrentClockFreqs []struct {
			// Device is the device argument value.
			Device nvml.Device
		}
		// DeviceGetCurrentClocksEventReasons holds details about calls to the DeviceGetCurrentClocksEventReasons method.
		DeviceGetCurrentClocksEventReasons []struct {
			// Device is the device argument value.
			Device nvml.Device
		}
		// DeviceGetCurrentClocksThrottleReasons holds details about calls to the DeviceGetCurrentClocksThrottleReasons method.
		DeviceGetCurrentClocksThrottleReasons []struct {
			// Device is the device argument value.
			Device nvml.Device
		}
		// DeviceGetDecoderUtilization holds details about calls to the DeviceGetDecoderUtilization method.
		DeviceGetDecoderUtilization []struct {
			// Device is the device argument value.
			Device nvml.Device
		}
		// DeviceGetDefaultApplicationsClock holds details about calls to the DeviceGetDefaultApplicationsClock method.
		DeviceGetDefaultApplicationsClock []struct {
			// Device is the device argument value.
			Device nvml.Device
			// ClockType is the clockType argument value.
			ClockType nvml.ClockType
		}
		// DeviceGetDefaultEccMode holds details about calls to the DeviceGetDefaultEccMode method.
		DeviceGetDefaultEccMode []struct {
			// Device is the device argument value.
			Device nvml.Device
		}
		// DeviceGetDetailedEccErrors holds details about calls to the DeviceGetDetailedEccErrors method.
		DeviceGetDetailedEccErrors []struct {
			// Device is the device argument value.
			Device nvml.Device
			// MemoryErrorType is the memoryErrorType argument value.
			MemoryErrorType nvml.MemoryErrorType
			// EccCounterType is the eccCounterType argument value.
			EccCounterType nvml.EccCounterType
		}
		// DeviceGetDeviceHandleFromMigDeviceHandle holds details about calls to the DeviceGetDeviceHandleFromMigDeviceHandle method.
		DeviceGetDeviceHandleFromMigDeviceHandle []struct {
			// Device is the device argument value.
			Device nvml.Device
		}
		// DeviceGetDisplayActive holds details about calls to the DeviceGetDisplayActive method.
		DeviceGetDisplayActive []struct {
			// Device is the device argument value.
			Device nvml.Device
		}
		// DeviceGetDisplayMode holds details about calls to the DeviceGetDisplayMode method.
		DeviceGetDisplayMode []struct {
			// Device is the device argument value.
			Device nvml.Device
		}
		// DeviceGetDramEncryptionMode holds details about calls to the DeviceGetDramEncryptionMode method.
		DeviceGetDramEncryptionMode []struct {
			// Device is the device argument value.
			Device nvml.Device
		}
		// DeviceGetDriverModel holds details about calls to the DeviceGetDriverModel method.
		DeviceGetDriverModel []struct {
			// Device is the device argument value.
			Device nvml.Device
		}
		// DeviceGetDriverModel_v2 holds details about calls to the DeviceGetDriverModel_v2 method.
		DeviceGetDriverModel_v2 []struct {
			// Device is the device argument value.
			Device nvml.Device
		}
		// DeviceGetDynamicPstatesInfo holds details about calls to the DeviceGetDynamicPstatesInfo method.
		DeviceGetDynamicPstatesInfo []struct {
			// Device is the device argument value.
			Device nvml.Device
		}
		// DeviceGetEccMode holds details about calls to the DeviceGetEccMode method.
		DeviceGetEccMode []struct {
			// Device is the device argument value.
			Device nvml.Device
		}
		// DeviceGetEncoderCapacity holds details about calls to the DeviceGetEncoderCapacity method.
		DeviceGetEncoderCapacity []struct {
			// Device is the device argument value.
			Device nvml.Device
			// EncoderType is the encoderType argument value.
			EncoderType nvml.EncoderType
		}
		// DeviceGetEncoderSessions holds details about calls to the DeviceGetEncoderSessions method.
		DeviceGetEncoderSessions []struct {
			// Device is the device argument value.
			Device nvml.Device
		}
		// DeviceGetEncoderStats holds details about calls to the DeviceGetEncoderStats method.
		DeviceGetEncoderStats []struct {
			// Device is the device argument value.
			Device nvml.Device
		}
		// DeviceGetEncoderUtilization holds details about calls to the DeviceGetEncoderUtilization method.
		DeviceGetEncoderUtilization []struct {
			// Device is the device argument value.
			Device nvml.Device
		}
		// DeviceGetEnforcedPowerLimit holds details about calls to the DeviceGetEnforcedPowerLimit method.
		DeviceGetEnforcedPowerLimit []struct {
			// Device is the device argument value.
			Device nvml.Device
		}
		// DeviceGetFBCSessions holds details about calls to the DeviceGetFBCSessions method.
		DeviceGetFBCSessions []struct {
			// Device is the device argument value.
			Device nvml.Device
		}
		// DeviceGetFBCStats holds details about calls to the DeviceGetFBCStats method.
		DeviceGetFBCStats []struct {
			// Device is the device argument value.
			Device nvml.Device
		}
		// DeviceGetFanControlPolicy_v2 holds details about calls to the DeviceGetFanControlPolicy_v2 method.
		DeviceGetFanControlPolicy_v2 []struct {
			// Device is the device argument value.
			Device nvml.Device
			// N is the n argument value.
			N int
		}
		// DeviceGetFanSpeed holds details about calls to the DeviceGetFanSpeed method.
		DeviceGetFanSpeed []struct {
			// Device is the device argument value.
			Device nvml.Device
		}
		// DeviceGetFanSpeedRPM holds details about calls to the DeviceGetFanSpeedRPM method.
		DeviceGetFanSpeedRPM []struct {
			// Device is the device argument value.
			Device nvml.Device
		}
		// DeviceGetFanSpeed_v2 holds details about calls to the DeviceGetFanSpeed_v2 method.
		DeviceGetFanSpeed_v2 []struct {
			// Device is the device argument value.
			Device nvml.Device
			// N is the n argument value.
			N int
		}
		// DeviceGetFieldValues holds details about calls to the DeviceGetFieldValues method.
		DeviceGetFieldValues []struct {
			// Device is the device argument value.
			Device nvml.Device
			// FieldValues is the fieldValues argument value.
			FieldValues []nvml.FieldValue
		}
		// DeviceGetGpcClkMinMaxVfOffset holds details about calls to the DeviceGetGpcClkMinMaxVfOffset method.
		DeviceGetGpcClkMinMaxVfOffset []struct {
			// Device is the device argument value.
			Device nvml.Device
		}
		// DeviceGetGpcClkVfOffset holds details about calls to the DeviceGetGpcClkVfOffset method.
		DeviceGetGpcClkVfOffset []struct {
			// Device is the device argument value.
			Device nvml.Device
		}
		// DeviceGetGpuFabricInfo holds details about calls to the DeviceGetGpuFabricInfo method.
		DeviceGetGpuFabricInfo []struct {
			// Device is the device argument value.
			Device nvml.Device
		}
		// DeviceGetGpuFabricInfoV holds details about calls to the DeviceGetGpuFabricInfoV method.
		DeviceGetGpuFabricInfoV []struct {
			// Device is the device argument value.
			Device nvml.Device
		}
		// DeviceGetGpuInstanceById holds details about calls to the DeviceGetGpuInstanceById method.
		DeviceGetGpuInstanceById []struct {
			// Device is the device argument value.
			Device nvml.Device
			// N is the n argument value.
			N int
		}
		// DeviceGetGpuInstanceId holds details about calls to the DeviceGetGpuInstanceId method.
		DeviceGetGpuInstanceId []struct {
			// Device is the device argument value.
			Device nvml.Device
		}
		// DeviceGetGpuInstancePossiblePlacements holds details about calls to the DeviceGetGpuInstancePossiblePlacements method.
		DeviceGetGpuInstancePossiblePlacements []struct {
			// Device is the device argument value.
			Device nvml.Device
			// GpuInstanceProfileInfo is the gpuInstanceProfileInfo argument value.
			GpuInstanceProfileInfo *nvml.GpuInstanceProfileInfo
		}
		// DeviceGetGpuInstanceProfileInfo holds details about calls to the DeviceGetGpuInstanceProfileInfo method.
		DeviceGetGpuInstanceProfileInfo []struct {
			// Device is the device argument value.
			Device nvml.Device
			// N is the n argument value.
			N int
		}
		// DeviceGetGpuInstanceProfileInfoByIdV holds details about calls to the DeviceGetGpuInstanceProfileInfoByIdV method.
		DeviceGetGpuInstanceProfileInfoByIdV []struct {
			// Device is the device argument value.
			Device nvml.Device
			// N is the n argument value.
			N int
		}
		// DeviceGetGpuInstanceProfileInfoV holds details about calls to the DeviceGetGpuInstanceProfileInfoV method.
		DeviceGetGpuInstanceProfileInfoV []struct {
			// Device is the device argument value.
			Device nvml.Device
			// N is the n argument value.
			N int
		}
		// DeviceGetGpuInstanceRemainingCapacity holds details about calls to the DeviceGetGpuInstanceRemainingCapacity method.
		DeviceGetGpuInstanceRemainingCapacity []struct {
			// Device is the device argument value.
			Device nvml.Device
			// GpuInstanceProfileInfo is the gpuInstanceProfileInfo argument value.
			GpuInstanceProfileInfo *nvml.GpuInstanceProfileInfo
		}
		// DeviceGetGpuInstances holds details about calls to the DeviceGetGpuInstances method.
		DeviceGetGpuInstances []struct {
			// Device is the device argument value.
			Device nvml.Device
			// GpuInstanceProfileInfo is the gpuInstanceProfileInfo argument value.
			GpuInstanceProfileInfo *nvml.GpuInstanceProfileInfo
		}
		// DeviceGetGpuMaxPcieLinkGeneration holds details about calls to the DeviceGetGpuMaxPcieLinkGeneration method.
		DeviceGetGpuMaxPcieLinkGeneration []struct {
			// Device is the device argument value.
			Device nvml.Device
		}
		// DeviceGetGpuOperationMode holds details about calls to the DeviceGetGpuOperationMode method.
		DeviceGetGpuOperationMode []struct {
			// Device is the device argument value.
			Device nvml.Device
		}
		// DeviceGetGraphicsRunningProcesses holds details about calls to the DeviceGetGraphicsRunningProcesses method.
		DeviceGetGraphicsRunningProcesses []struct {
			// Device is the device argument value.
			Device nvml.Device
		}
		// DeviceGetGridLicensableFeatures holds details about calls to the DeviceGetGridLicensableFeatures method.
		DeviceGetGridLicensableFeatures []struct {
			// Device is the device argument value.
			Device nvml.Device
		}
		// DeviceGetGspFirmwareMode holds details about calls to the DeviceGetGspFirmwareMode method.
		DeviceGetGspFirmwareMode []struct {
			// Device is the device argument value.
			Device nvml.Device
		}
		// DeviceGetGspFirmwareVersion holds details about calls to the DeviceGetGspFirmwareVersion method.
		DeviceGetGspFirmwareVersion []struct {
			// Device is the device argument value.
			Device nvml.Device
		}
		// DeviceGetHandleByIndex holds details about calls to the DeviceGetHandleByIndex method.
		DeviceGetHandleByIndex []struct {
			// N is the n argument value.
			N int
		}
		// DeviceGetHandleByPciBusId holds details about calls to the DeviceGetHandleByPciBusId method.
		DeviceGetHandleByPciBusId []struct {
			// S is the s argument value.
			S string
		}
		// DeviceGetHandleBySerial holds details about calls to the DeviceGetHandleBySerial method.
		DeviceGetHandleBySerial []struct {
			// S is the s argument value.
			S string
		}
		// DeviceGetHandleByUUID holds details about calls to the DeviceGetHandleByUUID method.
		DeviceGetHandleByUUID []struct {
			// S is the s argument value.
			S string
		}
		// DeviceGetHandleByUUIDV holds details about calls to the DeviceGetHandleByUUIDV method.
		DeviceGetHandleByUUIDV []struct {
			// UUID is the uUID argument value.
			UUID *nvml.UUID
		}
		// DeviceGetHostVgpuMode holds details about calls to the DeviceGetHostVgpuMode method.
		DeviceGetHostVgpuMode []struct {
			// Device is the device argument value.
			Device nvml.Device
		}
		// DeviceGetIndex holds details about calls to the DeviceGetIndex method.
		DeviceGetIndex []struct {
			// Device is the device argument value.
			Device nvml.Device
		}
		// DeviceGetInforomConfigurationChecksum holds details about calls to the DeviceGetInforomConfigurationChecksum method.
		DeviceGetInforomConfigurationChecksum []struct {
			// Device is the device argument value.
			Device nvml.Device
		}
		// DeviceGetInforomImageVersion holds details about calls to the DeviceGetInforomImageVersion method.
		DeviceGetInforomImageVersion []struct {
			// Device is the device argument value.
			Device nvml.Device
		}
		// DeviceGetInforomVersion holds details about calls to the DeviceGetInforomVersion method.
		DeviceGetInforomVersion []struct {
			// Device is the device argument value.
			Device nvml.Device
			// InforomObject is the inforomObject argument value.
			InforomObject nvml.InforomObject
		}
		// DeviceGetIrqNum holds details about calls to the DeviceGetIrqNum method.
		DeviceGetIrqNum []struct {
			// Device is the device argument value.
			Device nvml.Device
		}
		// DeviceGetJpgUtilization holds details about calls to the DeviceGetJpgUtilization method.
		DeviceGetJpgUtilization []struct {
			// Device is the device argument value.
			Device nvml.Device
		}
		// DeviceGetLastBBXFlushTime holds details about calls to the DeviceGetLastBBXFlushTime method.
		DeviceGetLastBBXFlushTime []struct {
			// Device is the device argument value.
			Device nvml.Device
		}
		// DeviceGetMPSComputeRunningProcesses holds details about calls to the DeviceGetMPSComputeRunningProcesses method.
		DeviceGetMPSComputeRunningProcesses []struct {
			// Device is the device argument value.
			Device nvml.Device
		}
		// DeviceGetMarginTemperature holds details about calls to the DeviceGetMarginTemperature method.
		DeviceGetMarginTemperature []struct {
			// Device is the device argument value.
			Device nvml.Device
		}
		// DeviceGetMaxClockInfo holds details about calls to the DeviceGetMaxClockInfo method.
		DeviceGetMaxClockInfo []struct {
			// Device is the device argument value.
			Device nvml.Device
			// ClockType is the clockType argument value.
			ClockType nvml.ClockType
		}
		// DeviceGetMaxCustomerBoostClock holds details about calls to the DeviceGetMaxCustomerBoostClock method.
		DeviceGetMaxCustomerBoostClock []struct {
			// Device is the device argument value.
			Device nvml.Device
			// ClockType is the clockType argument value.
			ClockType nvml.ClockType
		}
		// DeviceGetMaxMigDeviceCount holds details about calls to the DeviceGetMaxMigDeviceCount method.
		DeviceGetMaxMigDeviceCount []struct {
			// Device is the device argument value.
			Device nvml.Device
		}
		// DeviceGetMaxPcieLinkGeneration holds details about calls to the DeviceGetMaxPcieLinkGeneration method.
		DeviceGetMaxPcieLinkGeneration []struct {
			// Device is the device argument value.
			Device nvml.Device
		}
		// DeviceGetMaxPcieLinkWidth holds details about calls to the DeviceGetMaxPcieLinkWidth method.
		DeviceGetMaxPcieLinkWidth []struct {
			// Device is the device argument value.
			Device nvml.Device
		}
		// DeviceGetMemClkMinMaxVfOffset holds details about calls to the DeviceGetMemClkMinMaxVfOffset method.
		DeviceGetMemClkMinMaxVfOffset []struct {
			// Device is the device argument value.
			Device nvml.Device
		}
		// DeviceGetMemClkVfOffset holds details about calls to the DeviceGetMemClkVfOffset method.
		DeviceGetMemClkVfOffset []struct {
			// Device is the device argument value.
			Device nvml.Device
		}
		// DeviceGetMemoryAffinity holds details about calls to the DeviceGetMemoryAffinity method.
		DeviceGetMemoryAffinity []struct {
			// Device is the device argument value.
			Device nvml.Device
			// N is the n argument value.
			N int
			// AffinityScope is the affinityScope argument value.
			AffinityScope nvml.AffinityScope
		}
		// DeviceGetMemoryBusWidth holds details about calls to the DeviceGetMemoryBusWidth method.
		DeviceGetMemoryBusWidth []struct {
			// Device is the device argument value.
			Device nvml.Device
		}
		// DeviceGetMemoryErrorCounter holds details about calls to the DeviceGetMemoryErrorCounter method.
		DeviceGetMemoryErrorCounter []struct {
			// Device is the device argument value.
			Device nvml.Device
			// MemoryErrorType is the memoryErrorType argument value.
			MemoryErrorType nvml.MemoryErrorType
			// EccCounterType is the eccCounterType argument value.
			EccCounterType nvml.EccCounterType
			// MemoryLocation is the memoryLocation argument value.
			MemoryLocation nvml.MemoryLocation
		}
		// DeviceGetMemoryInfo holds details about calls to the DeviceGetMemoryInfo method.
		DeviceGetMemoryInfo []struct {
			// Device is the device argument value.
			Device nvml.Device
		}
		// DeviceGetMemoryInfo_v2 holds details about calls to the DeviceGetMemoryInfo_v2 method.
		DeviceGetMemoryInfo_v2 []struct {
			// Device is the device argument value.
			Device nvml.Device
		}
		// DeviceGetMigDeviceHandleByIndex holds details about calls to the DeviceGetMigDeviceHandleByIndex method.
		DeviceGetMigDeviceHandleByIndex []struct {
			// Device is the device argument value.
			Device nvml.Device
			// N is the n argument value.
			N int
		}
		// DeviceGetMigMode holds details about calls to the DeviceGetMigMode method.
		DeviceGetMigMode []struct {
			// Device is the device argument value.
			Device nvml.Device
		}
		// DeviceGetMinMaxClockOfPState holds details about calls to the DeviceGetMinMaxClockOfPState method.
		DeviceGetMinMaxClockOfPState []struct {
			// Device is the device argument value.
			Device nvml.Device
			// ClockType is the clockType argument value.
			ClockType nvml.ClockType
			// Pstates is the pstates argument value.
			Pstates nvml.Pstates
		}
		// DeviceGetMinMaxFanSpeed holds details about calls to the DeviceGetMinMaxFanSpeed method.
		DeviceGetMinMaxFanSpeed []struct {
			// Device is the device argument value.
			Device nvml.Device
		}
		// DeviceGetMinorNumber holds details about calls to the DeviceGetMinorNumber method.
		DeviceGetMinorNumber []struct {
			// Device is the device argument value.
			Device nvml.Device
		}
		// DeviceGetModuleId holds details about calls to the DeviceGetModuleId method.
		DeviceGetModuleId []struct {
			// Device is the device argument value.
			Device nvml.Device
		}
		// DeviceGetMultiGpuBoard holds details about calls to the DeviceGetMultiGpuBoard method.
		DeviceGetMultiGpuBoard []struct {
			// Device is the device argument value.
			Device nvml.Device
		}
		// DeviceGetName holds details about calls to the DeviceGetName method.
		DeviceGetName []struct {
			// Device is the device argument value.
			Device nvml.Device
		}
		// DeviceGetNumFans holds details about calls to the DeviceGetNumFans method.
		DeviceGetNumFans []struct {
			// Device is the device argument value.
			Device nvml.Device
		}
		// DeviceGetNumGpuCores holds details about calls to the DeviceGetNumGpuCores method.
		DeviceGetNumGpuCores []struct {
			// Device is the device argument value.
			Device nvml.Device
		}
		// DeviceGetNumaNodeId holds details about calls to the DeviceGetNumaNodeId method.
		DeviceGetNumaNodeId []struct {
			// Device is the device argument value.
			Device nvml.Device
		}
		// DeviceGetNvLinkCapability holds details about calls to the DeviceGetNvLinkCapability method.
		DeviceGetNvLinkCapability []struct {
			// Device is the device argument value.
			Device nvml.Device
			// N is the n argument value.
			N int
			// NvLinkCapability is the nvLinkCapability argument value.
			NvLinkCapability nvml.NvLinkCapability
		}
		// DeviceGetNvLinkErrorCounter holds details about calls to the DeviceGetNvLinkErrorCounter method.
		DeviceGetNvLinkErrorCounter []struct {
			// Device is the device argument value.
			Device nvml.Device
			// N is the n argument value.
			N int
			// NvLinkErrorCounter is the nvLinkErrorCounter argument value.
			NvLinkErrorCounter nvml.NvLinkErrorCounter
		}
		// DeviceGetNvLinkInfo holds details about calls to the DeviceGetNvLinkInfo method.
		DeviceGetNvLinkInfo []struct {
			// Device is the device argument value.
			Device nvml.Device
		}
		// DeviceGetNvLinkRemoteDeviceType holds details about calls to the DeviceGetNvLinkRemoteDeviceType method.
		DeviceGetNvLinkRemoteDeviceType []struct {
			// Device is the device argument value.
			Device nvml.Device
			// N is the n argument value.
			N int
		}
		// DeviceGetNvLinkRemotePciInfo holds details about calls to the DeviceGetNvLinkRemotePciInfo method.
		DeviceGetNvLinkRemotePciInfo []struct {
			// Device is the device argument value.
			Device nvml.Device
			// N is the n argument value.
			N int
		}
		// DeviceGetNvLinkState holds details about calls to the DeviceGetNvLinkState method.
		DeviceGetNvLinkState []struct {
			// Device is the device argument value.
			Device nvml.Device
			// N is the n argument value.
			N int
		}
		// DeviceGetNvLinkUtilizationControl holds details about calls to the DeviceGetNvLinkUtilizationControl method.
		DeviceGetNvLinkUtilizationControl []struct {
			// Device is the device argument value.
			Device nvml.Device
			// N1 is the n1 argument value.
			N1 int
			// N2 is the n2 argument value.
			N2 int
		}
		// DeviceGetNvLinkUtilizationCounter holds details about calls to the DeviceGetNvLinkUtilizationCounter method.
		DeviceGetNvLinkUtilizationCounter []struct {
			// Device is the device argument value.
			Device nvml.Device
			// N1 is the n1 argument value.
			N1 int
			// N2 is the n2 argument value.
			N2 int
		}
		// DeviceGetNvLinkVersion holds details about calls to the DeviceGetNvLinkVersion method.
		DeviceGetNvLinkVersion []struct {
			// Device is the device argument value.
			Device nvml.Device
			// N is the n argument value.
			N int
		}
		// DeviceGetNvlinkBwMode holds details about calls to the DeviceGetNvlinkBwMode method.
		DeviceGetNvlinkBwMode []struct {
			// Device is the device argument value.
			Device nvml.Device
		}
		// DeviceGetNvlinkSupportedBwModes holds details about calls to the DeviceGetNvlinkSupportedBwModes method.
		DeviceGetNvlinkSupportedBwModes []struct {
			// Device is the device argument value.
			Device nvml.Device
		}
		// DeviceGetOfaUtilization holds details about calls to the DeviceGetOfaUtilization method.
		DeviceGetOfaUtilization []struct {
			// Device is the device argument value.
			Device nvml.Device
		}
		// DeviceGetP2PStatus holds details about calls to the DeviceGetP2PStatus method.
		DeviceGetP2PStatus []struct {
			// Device1 is the device1 argument value.
			Device1 nvml.Device
			// Device2 is the device2 argument value.
			Device2 nvml.Device
			// GpuP2PCapsIndex is the gpuP2PCapsIndex argument value.
			GpuP2PCapsIndex nvml.GpuP2PCapsIndex
		}
		// DeviceGetPciInfo holds details about calls to the DeviceGetPciInfo method.
		DeviceGetPciInfo []struct {
			// Device is the device argument value.
			Device nvml.Device
		}
		// DeviceGetPciInfoExt holds details about calls to the DeviceGetPciInfoExt method.
		DeviceGetPciInfoExt []struct {
			// Device is the device argument value.
			Device nvml.Device
		}
		// DeviceGetPcieLinkMaxSpeed holds details about calls to the DeviceGetPcieLinkMaxSpeed method.
		DeviceGetPcieLinkMaxSpeed []struct {
			// Device is the device argument value.
			Device nvml.Device
		}
		// DeviceGetPcieReplayCounter holds details about calls to the DeviceGetPcieReplayCounter method.
		DeviceGetPcieReplayCounter []struct {
			// Device is the device argument value.
			Device nvml.Device
		}
		// DeviceGetPcieSpeed holds details about calls to the DeviceGetPcieSpeed method.
		DeviceGetPcieSpeed []struct {
			// Device is the device argument value.
			Device nvml.Device
		}
		// DeviceGetPcieThroughput holds details about calls to the DeviceGetPcieThroughput method.
		DeviceGetPcieThroughput []struct {
			// Device is the device argument value.
			Device nvml.Device
			// PcieUtilCounter is the pcieUtilCounter argument value.
			PcieUtilCounter nvml.PcieUtilCounter
		}
		// DeviceGetPdi holds details about calls to the DeviceGetPdi method.
		DeviceGetPdi []struct {
			// Device is the device argument value.
			Device nvml.Device
		}
		// DeviceGetPerformanceModes holds details about calls to the DeviceGetPerformanceModes method.
		DeviceGetPerformanceModes []struct {
			// Device is the device argument value.
			Device nvml.Device
		}
		// DeviceGetPerformanceState holds details about calls to the DeviceGetPerformanceState method.
		DeviceGetPerformanceState []struct {
			// Device is the device argument value.
			Device nvml.Device
		}
		// DeviceGetPersistenceMode holds details about calls to the DeviceGetPersistenceMode method.
		DeviceGetPersistenceMode []struct {
			// Device is the device argument value.
			Device nvml.Device
		}
		// DeviceGetPgpuMetadataString holds details about calls to the DeviceGetPgpuMetadataString method.
		DeviceGetPgpuMetadataString []struct {
			// Device is the device argument value.
			Device nvml.Device
		}
		// DeviceGetPlatformInfo holds details about calls to the DeviceGetPlatformInfo method.
		DeviceGetPlatformInfo []struct {
			// Device is the device argument value.
			Device nvml.Device
		}
		// DeviceGetPowerManagementDefaultLimit holds details about calls to the DeviceGetPowerManagementDefaultLimit method.
		DeviceGetPowerManagementDefaultLimit []struct {
			// Device is the device argument value.
			Device nvml.Device
		}
		// DeviceGetPowerManagementLimit holds details about calls to the DeviceGetPowerManagementLimit method.
		DeviceGetPowerManagementLimit []struct {
			// Device is the device argument value.
			Device nvml.Device
		}
		// DeviceGetPowerManagementLimitConstraints holds details about calls to the DeviceGetPowerManagementLimitConstraints method.
		DeviceGetPowerManagementLimitConstraints []struct {
			// Device is the device argument value.
			Device nvml.Device
		}
		// DeviceGetPowerManagementMode holds details about calls to the DeviceGetPowerManagementMode method.
		DeviceGetPowerManagementMode []struct {
			// Device is the device argument value.
			Device nvml.Device
		}
		// DeviceGetPowerMizerMode_v1 holds details about calls to the DeviceGetPowerMizerMode_v1 method.
		DeviceGetPowerMizerMode_v1 []struct {
			// Device is the device argument value.
			Device nvml.Device
		}
		// DeviceGetPowerSource holds details about calls to the DeviceGetPowerSource method.
		DeviceGetPowerSource []struct {
			// Device is the device argument value.
			Device nvml.Device
		}
		// DeviceGetPowerState holds details about calls to the DeviceGetPowerState method.
		DeviceGetPowerState []struct {
			// Device is the device argument value.
			Device nvml.Device
		}
		// DeviceGetPowerUsage holds details about calls to the DeviceGetPowerUsage method.
		DeviceGetPowerUsage []struct {
			// Device is the device argument value.
			Device nvml.Device
		}
		// DeviceGetProcessUtilization holds details about calls to the DeviceGetProcessUtilization method.
		DeviceGetProcessUtilization []struct {
			// Device is the device argument value.
			Device nvml.Device
			// V is the v argument value.
			V uint64
		}
		// DeviceGetProcessesUtilizationInfo holds details about calls to the DeviceGetProcessesUtilizationInfo method.
		DeviceGetProcessesUtilizationInfo []struct {
			// Device is the device argument value.
			Device nvml.Device
		}
		// DeviceGetRemappedRows holds details about calls to the DeviceGetRemappedRows method.
		DeviceGetRemappedRows []struct {
			// Device is the device argument value.
			Device nvml.Device
		}
		// DeviceGetRepairStatus holds details about calls to the DeviceGetRepairStatus method.
		DeviceGetRepairStatus []struct {
			// Device is the device argument value.
			Device nvml.Device
		}
		// DeviceGetRetiredPages holds details about calls to the DeviceGetRetiredPages method.
		DeviceGetRetiredPages []struct {
			// Device is the device argument value.
			Device nvml.Device
			// PageRetirementCause is the pageRetirementCause argument value.
			PageRetirementCause nvml.PageRetirementCause
		}
		// DeviceGetRetiredPagesPendingStatus holds details about calls to the DeviceGetRetiredPagesPendingStatus method.
		DeviceGetRetiredPagesPendingStatus []struct {
			// Device is the device argument value.
			Device nvml.Device
		}
		// DeviceGetRetiredPages_v2 holds details about calls to the DeviceGetRetiredPages_v2 method.
		DeviceGetRetiredPages_v2 []struct {
			// Device is the device argument value.
			Device nvml.Device
			// PageRetirementCause is the pageRetirementCause argument value.
			PageRetirementCause nvml.PageRetirementCause
		}
		// DeviceGetRowRemapperHistogram holds details about calls to the DeviceGetRowRemapperHistogram method.
		DeviceGetRowRemapperHistogram []struct {
			// Device is the device argument value.
			Device nvml.Device
		}
		// DeviceGetRunningProcessDetailList holds details about calls to the DeviceGetRunningProcessDetailList method.
		DeviceGetRunningProcessDetailList []struct {
			// Device is the device argument value.
			Device nvml.Device
		}
		// DeviceGetSamples holds details about calls to the DeviceGetSamples method.
		DeviceGetSamples []struct {
			// Device is the device argument value.
			Device nvml.Device
			// SamplingType is the samplingType argument value.
			SamplingType nvml.SamplingType
			// V is the v argument value.
			V uint64
		}
		// DeviceGetSerial holds details about calls to the DeviceGetSerial method.
		DeviceGetSerial []struct {
			// Device is the device argument value.
			Device nvml.Device
		}
		// DeviceGetSramEccErrorStatus holds details about calls to the DeviceGetSramEccErrorStatus method.
		DeviceGetSramEccErrorStatus []struct {
			// Device is the device argument value.
			Device nvml.Device
		}
		// DeviceGetSramUniqueUncorrectedEccErrorCounts holds details about calls to the DeviceGetSramUniqueUncorrectedEccErrorCounts method.
		DeviceGetSramUniqueUncorrectedEccErrorCounts []struct {
			// Device is the device argument value.
			Device nvml.Device
			// EccSramUniqueUncorrectedErrorCounts is the eccSramUniqueUncorrectedErrorCounts argument value.
			EccSramUniqueUncorrectedErrorCounts *nvml.EccSramUniqueUncorrectedErrorCounts
		}
		// DeviceGetSupportedClocksEventReasons holds details about calls to the DeviceGetSupportedClocksEventReasons method.
		DeviceGetSupportedClocksEventReasons []struct {
			// Device is the device argument value.
			Device nvml.Device
		}
		// DeviceGetSupportedClocksThrottleReasons holds details about calls to the DeviceGetSupportedClocksThrottleReasons method.
		DeviceGetSupportedClocksThrottleReasons []struct {
			// Device is the device argument value.
			Device nvml.Device
		}
		// DeviceGetSupportedEventTypes holds details about calls to the DeviceGetSupportedEventTypes method.
		DeviceGetSupportedEventTypes []struct {
			// Device is the device argument value.
			Device nvml.Device
		}
		// DeviceGetSupportedGraphicsClocks holds details about calls to the DeviceGetSupportedGraphicsClocks method.
		DeviceGetSupportedGraphicsClocks []struct {
			// Device is the device argument value.
			Device nvml.Device
			// N is the n argument value.
			N int
		}
		// DeviceGetSupportedMemoryClocks holds details about calls to the DeviceGetSupportedMemoryClocks method.
		DeviceGetSupportedMemoryClocks []struct {
			// Device is the device argument value.
			Device nvml.Device
		}
		// DeviceGetSupportedPerformanceStates holds details about calls to the DeviceGetSupportedPerformanceStates method.
		DeviceGetSupportedPerformanceStates []struct {
			// Device is the device argument value.
			Device nvml.Device
		}
		// DeviceGetSupportedVgpus holds details about calls to the DeviceGetSupportedVgpus method.
		DeviceGetSupportedVgpus []struct {
			// Device is the device argument value.
			Device nvml.Device
		}
		// DeviceGetTargetFanSpeed holds details about calls to the DeviceGetTargetFanSpeed method.
		DeviceGetTargetFanSpeed []struct {
			// Device is the device argument value.
			Device nvml.Device
			// N is the n argument value.
			N int
		}
		// DeviceGetTemperature holds details about calls to the DeviceGetTemperature method.
		DeviceGetTemperature []struct {
			// Device is the device argument value.
			Device nvml.Device
			// TemperatureSensors is the temperatureSensors argument value.
			TemperatureSensors nvml.TemperatureSensors
		}
		// DeviceGetTemperatureThreshold holds details about calls to the DeviceGetTemperatureThreshold method.
		DeviceGetTemperatureThreshold []struct {
			// Device is the device argument value.
			Device nvml.Device
			// TemperatureThresholds is the temperatureThresholds argument value.
			TemperatureThresholds nvml.TemperatureThresholds
		}
		// DeviceGetTemperatureV holds details about calls to the DeviceGetTemperatureV method.
		DeviceGetTemperatureV []struct {
			// Device is the device argument value.
			Device nvml.Device
		}
		// DeviceGetThermalSettings holds details about calls to the DeviceGetThermalSettings method.
		DeviceGetThermalSettings []struct {
			// Device is the device argument value.
			Device nvml.Device
			// V is the v argument value.
			V uint32
		}
		// DeviceGetTopologyCommonAncestor holds details about calls to the DeviceGetTopologyCommonAncestor method.
		DeviceGetTopologyCommonAncestor []struct {
			// Device1 is the device1 argument value.
			Device1 nvml.Device
			// Device2 is the device2 argument value.
			Device2 nvml.Device
		}
		// DeviceGetTopologyNearestGpus holds details about calls to the DeviceGetTopologyNearestGpus method.
		DeviceGetTopologyNearestGpus []struct {
			// Device is the device argument value.
			Device nvml.Device
			// GpuTopologyLevel is the gpuTopologyLevel argument value.
			GpuTopologyLevel nvml.GpuTopologyLevel
		}
		// DeviceGetTotalEccErrors holds details about calls to the DeviceGetTotalEccErrors method.
		DeviceGetTotalEccErrors []struct {
			// Device is the device argument value.
			Device nvml.Device
			// MemoryErrorType is the memoryErrorType argument value.
			MemoryErrorType nvml.MemoryErrorType
			// EccCounterType is the eccCounterType argument value.
			EccCounterType nvml.EccCounterType
		}
		// DeviceGetTotalEnergyConsumption holds details about calls to the DeviceGetTotalEnergyConsumption method.
		DeviceGetTotalEnergyConsumption []struct {
			// Device is the device argument value.
			Device nvml.Device
		}
		// DeviceGetUUID holds details about calls to the DeviceGetUUID method.
		DeviceGetUUID []struct {
			// Device is the device argument value.
			Device nvml.Device
		}
		// DeviceGetUtilizationRates holds details about calls to the DeviceGetUtilizationRates method.
		DeviceGetUtilizationRates []struct {
			// Device is the device argument value.
			Device nvml.Device
		}
		// DeviceGetVbiosVersion holds details about calls to the DeviceGetVbiosVersion method.
		DeviceGetVbiosVersion []struct {
			// Device is the device argument value.
			Device nvml.Device
		}
		// DeviceGetVgpuCapabilities holds details about calls to the DeviceGetVgpuCapabilities method.
		DeviceGetVgpuCapabilities []struct {
			// Device is the device argument value.
			Device nvml.Device
			// DeviceVgpuCapability is the deviceVgpuCapability argument value.
			DeviceVgpuCapability nvml.DeviceVgpuCapability
		}
		// DeviceGetVgpuHeterogeneousMode holds details about calls to the DeviceGetVgpuHeterogeneousMode method.
		DeviceGetVgpuHeterogeneousMode []struct {
			// Device is the device argument value.
			Device nvml.Device
		}
		// DeviceGetVgpuInstancesUtilizationInfo holds details about calls to the DeviceGetVgpuInstancesUtilizationInfo method.
		DeviceGetVgpuInstancesUtilizationInfo []struct {
			// Device is the device argument value.
			Device nvml.Device
		}
		// DeviceGetVgpuMetadata holds details about calls to the DeviceGetVgpuMetadata method.
		DeviceGetVgpuMetadata []struct {
			// Device is the device argument value.
			Device nvml.Device
		}
		// DeviceGetVgpuProcessUtilization holds details about calls to the DeviceGetVgpuProcessUtilization method.
		DeviceGetVgpuProcessUtilization []struct {
			// Device is the device argument value.
			Device nvml.Device
			// V is the v argument value.
			V uint64
		}
		// DeviceGetVgpuProcessesUtilizationInfo holds details about calls to the DeviceGetVgpuProcessesUtilizationInfo method.
		DeviceGetVgpuProcessesUtilizationInfo []struct {
			// Device is the device argument value.
			Device nvml.Device
		}
		// DeviceGetVgpuSchedulerCapabilities holds details about calls to the DeviceGetVgpuSchedulerCapabilities method.
		DeviceGetVgpuSchedulerCapabilities []struct {
			// Device is the device argument value.
			Device nvml.Device
		}
		// DeviceGetVgpuSchedulerLog holds details about calls to the DeviceGetVgpuSchedulerLog method.
		DeviceGetVgpuSchedulerLog []struct {
			// Device is the device argument value.
			Device nvml.Device
		}
		// DeviceGetVgpuSchedulerState holds details about calls to the DeviceGetVgpuSchedulerState method.
		DeviceGetVgpuSchedulerState []struct {
			// Device is the device argument value.
			Device nvml.Device
		}
		// DeviceGetVgpuTypeCreatablePlacements holds details about calls to the DeviceGetVgpuTypeCreatablePlacements method.
		DeviceGetVgpuTypeCreatablePlacements []struct {
			// Device is the device argument value.
			Device nvml.Device
			// VgpuTypeId is the vgpuTypeId argument value.
			VgpuTypeId nvml.VgpuTypeId
		}
		// DeviceGetVgpuTypeSupportedPlacements holds details about calls to the DeviceGetVgpuTypeSupportedPlacements method.
		DeviceGetVgpuTypeSupportedPlacements []struct {
			// Device is the device argument value.
			Device nvml.Device
			// VgpuTypeId is the vgpuTypeId argument value.
			VgpuTypeId nvml.VgpuTypeId
		}
		// DeviceGetVgpuUtilization holds details about calls to the DeviceGetVgpuUtilization method.
		DeviceGetVgpuUtilization []struct {
			// Device is the device argument value.
			Device nvml.Device
			// V is the v argument value.
			V uint64
		}
		// DeviceGetViolationStatus holds details about calls to the DeviceGetViolationStatus method.
		DeviceGetViolationStatus []struct {
			// Device is the device argument value.
			Device nvml.Device
			// PerfPolicyType is the perfPolicyType argument value.
			PerfPolicyType nvml.PerfPolicyType
		}
		// DeviceGetVirtualizationMode holds details about calls to the DeviceGetVirtualizationMode method.
		DeviceGetVirtualizationMode []struct {
			// Device is the device argument value.
			Device nvml.Device
		}
		// DeviceIsMigDeviceHandle holds details about calls to the DeviceIsMigDeviceHandle method.
		DeviceIsMigDeviceHandle []struct {
			// Device is the device argument value.
			Device nvml.Device
		}
		// DeviceModifyDrainState holds details about calls to the DeviceModifyDrainState method.
		DeviceModifyDrainState []struct {
			// PciInfo is the pciInfo argument value.
			PciInfo *nvml.PciInfo
			// EnableState is the enableState argument value.
			EnableState nvml.EnableState
		}
		// DeviceOnSameBoard holds details about calls to the DeviceOnSameBoard method.
		DeviceOnSameBoard []struct {
			// Device1 is the device1 argument value.
			Device1 nvml.Device
			// Device2 is the device2 argument value.
			Device2 nvml.Device
		}
		// DevicePowerSmoothingActivatePresetProfile holds details about calls to the DevicePowerSmoothingActivatePresetProfile method.
		DevicePowerSmoothingActivatePresetProfile []struct {
			// Device is the device argument value.
			Device nvml.Device
			// PowerSmoothingProfile is the powerSmoothingProfile argument value.
			PowerSmoothingProfile *nvml.PowerSmoothingProfile
		}
		// DevicePowerSmoothingSetState holds details about calls to the DevicePowerSmoothingSetState method.
		DevicePowerSmoothingSetState []struct {
			// Device is the device argument value.
			Device nvml.Device
			// PowerSmoothingState is the powerSmoothingState argument value.
			PowerSmoothingState *nvml.PowerSmoothingState
		}
		// DevicePowerSmoothingUpdatePresetProfileParam holds details about calls to the DevicePowerSmoothingUpdatePresetProfileParam method.
		DevicePowerSmoothingUpdatePresetProfileParam []struct {
			// Device is the device argument value.
			Device nvml.Device
			// PowerSmoothingProfile is the powerSmoothingProfile argument value.
			PowerSmoothingProfile *nvml.PowerSmoothingProfile
		}
		// DeviceQueryDrainState holds details about calls to the DeviceQueryDrainState method.
		DeviceQueryDrainState []struct {
			// PciInfo is the pciInfo argument value.
			PciInfo *nvml.PciInfo
		}
		// DeviceReadWritePRM_v1 holds details about calls to the DeviceReadWritePRM_v1 method.
		DeviceReadWritePRM_v1 []struct {
			// Device is the device argument value.
			Device nvml.Device
			// PRMTLV_v1 is the pRMTLV_v1 argument value.
			PRMTLV_v1 *nvml.PRMTLV_v1
		}
		// DeviceRegisterEvents holds details about calls to the DeviceRegisterEvents method.
		DeviceRegisterEvents []struct {
			// Device is the device argument value.
			Device nvml.Device
			// V is the v argument value.
			V uint64
			// EventSet is the eventSet argument value.
			EventSet nvml.EventSet
		}
		// DeviceRemoveGpu holds details about calls to the DeviceRemoveGpu method.
		DeviceRemoveGpu []struct {
			// PciInfo is the pciInfo argument value.
			PciInfo *nvml.PciInfo
		}
		// DeviceRemoveGpu_v2 holds details about calls to the DeviceRemoveGpu_v2 method.
		DeviceRemoveGpu_v2 []struct {
			// PciInfo is the pciInfo argument value.
			PciInfo *nvml.PciInfo
			// DetachGpuState is the detachGpuState argument value.
			DetachGpuState nvml.DetachGpuState
			// PcieLinkState is the pcieLinkState argument value.
			PcieLinkState nvml.PcieLinkState
		}
		// DeviceResetApplicationsClocks holds details about calls to the DeviceResetApplicationsClocks method.
		DeviceResetApplicationsClocks []struct {
			// Device is the device argument value.
			Device nvml.Device
		}
		// DeviceResetGpuLockedClocks holds details about calls to the DeviceResetGpuLockedClocks method.
		DeviceResetGpuLockedClocks []struct {
			// Device is the device argument value.
			Device nvml.Device
		}
		// DeviceResetMemoryLockedClocks holds details about calls to the DeviceResetMemoryLockedClocks method.
		DeviceResetMemoryLockedClocks []struct {
			// Device is the device argument value.
			Device nvml.Device
		}
		// DeviceResetNvLinkErrorCounters holds details about calls to the DeviceResetNvLinkErrorCounters method.
		DeviceResetNvLinkErrorCounters []struct {
			// Device is the device argument value.
			Device nvml.Device
			// N is the n argument value.
			N int
		}
		// DeviceResetNvLinkUtilizationCounter holds details about calls to the DeviceResetNvLinkUtilizationCounter method.
		DeviceResetNvLinkUtilizationCounter []struct {
			// Device is the device argument value.
			Device nvml.Device
			// N1 is the n1 argument value.
			N1 int
			// N2 is the n2 argument value.
			N2 int
		}
		// DeviceSetAPIRestriction holds details about calls to the DeviceSetAPIRestriction method.
		DeviceSetAPIRestriction []struct {
			// Device is the device argument value.
			Device nvml.Device
			// RestrictedAPI is the restrictedAPI argument value.
			RestrictedAPI nvml.RestrictedAPI
			// EnableState is the enableState argument value.
			EnableState nvml.EnableState
		}
		// DeviceSetAccountingMode holds details about calls to the DeviceSetAccountingMode method.
		DeviceSetAccountingMode []struct {
			// Device is the device argument value.
			Device nvml.Device
			// EnableState is the enableState argument value.
			EnableState nvml.EnableState
		}
		// DeviceSetApplicationsClocks holds details about calls to the DeviceSetApplicationsClocks method.
		DeviceSetApplicationsClocks []struct {
			// Device is the device argument value.
			Device nvml.Device
			// V1 is the v1 argument value.
			V1 uint32
			// V2 is the v2 argument value.
			V2 uint32
		}
		// DeviceSetAutoBoostedClocksEnabled holds details about calls to the DeviceSetAutoBoostedClocksEnabled method.
		DeviceSetAutoBoostedClocksEnabled []struct {
			// Device is the device argument value.
			Device nvml.Device
			// EnableState is the enableState argument value.
			EnableState nvml.EnableState
		}
		// DeviceSetClockOffsets holds details about calls to the DeviceSetClockOffsets method.
		DeviceSetClockOffsets []struct {
			// Device is the device argument value.
			Device nvml.Device
			// ClockOffset is the clockOffset argument value.
			ClockOffset nvml.ClockOffset
		}
		// DeviceSetComputeMode holds details about calls to the DeviceSetComputeMode method.
		DeviceSetComputeMode []struct {
			// Device is the device argument value.
			Device nvml.Device
			// ComputeMode is the computeMode argument value.
			ComputeMode nvml.ComputeMode
		}
		// DeviceSetConfComputeUnprotectedMemSize holds details about calls to the DeviceSetConfComputeUnprotectedMemSize method.
		DeviceSetConfComputeUnprotectedMemSize []struct {
			// Device is the device argument value.
			Device nvml.Device
			// V is the v argument value.
			V uint64
		}
		// DeviceSetCpuAffinity holds details about calls to the DeviceSetCpuAffinity method.
		DeviceSetCpuAffinity []struct {
			// Device is the device argument value.
			Device nvml.Device
		}
		// DeviceSetDefaultAutoBoostedClocksEnabled holds details about calls to the DeviceSetDefaultAutoBoostedClocksEnabled method.
		DeviceSetDefaultAutoBoostedClocksEnabled []struct {
			// Device is the device argument value.
			Device nvml.Device
			// EnableState is the enableState argument value.
			EnableState nvml.EnableState
			// V is the v argument value.
			V uint32
		}
		// DeviceSetDefaultFanSpeed_v2 holds details about calls to the DeviceSetDefaultFanSpeed_v2 method.
		DeviceSetDefaultFanSpeed_v2 []struct {
			// Device is the device argument value.
			Device nvml.Device
			// N is the n argument value.
			N int
		}
		// DeviceSetDramEncryptionMode holds details about calls to the DeviceSetDramEncryptionMode method.
		DeviceSetDramEncryptionMode []struct {
			// Device is the device argument value.
			Device nvml.Device
			// DramEncryptionInfo is the dramEncryptionInfo argument value.
			DramEncryptionInfo *nvml.DramEncryptionInfo
		}
		// DeviceSetDriverModel holds details about calls to the DeviceSetDriverModel method.
		DeviceSetDriverModel []struct {
			// Device is the device argument value.
			Device nvml.Device
			// DriverModel is the driverModel argument value.
			DriverModel nvml.DriverModel
			// V is the v argument value.
			V uint32
		}
		// DeviceSetEccMode holds details about calls to the DeviceSetEccMode method.
		DeviceSetEccMode []struct {
			// Device is the device argument value.
			Device nvml.Device
			// EnableState is the enableState argument value.
			EnableState nvml.EnableState
		}
		// DeviceSetFanControlPolicy holds details about calls to the DeviceSetFanControlPolicy method.
		DeviceSetFanControlPolicy []struct {
			// Device is the device argument value.
			Device nvml.Device
			// N is the n argument value.
			N int
			// FanControlPolicy is the fanControlPolicy argument value.
			FanControlPolicy nvml.FanControlPolicy
		}
		// DeviceSetFanSpeed_v2 holds details about calls to the DeviceSetFanSpeed_v2 method.
		DeviceSetFanSpeed_v2 []struct {
			// Device is the device argument value.
			Device nvml.Device
			// N1 is the n1 argument value.
			N1 int
			// N2 is the n2 argument value.
			N2 int
		}
		// DeviceSetGpcClkVfOffset holds details about calls to the DeviceSetGpcClkVfOffset method.
		DeviceSetGpcClkVfOffset []struct {
			// Device is the device argument value.
			Device nvml.Device
			// N is the n argument value.
			N int
		}
		// DeviceSetGpuLockedClocks holds details about calls to the DeviceSetGpuLockedClocks method.
		DeviceSetGpuLockedClocks []struct {
			// Device is the device argument value.
			Device nvml.Device
			// V1 is the v1 argument value.
			V1 uint32
			// V2 is the v2 argument value.
			V2 uint32
		}
		// DeviceSetGpuOperationMode holds details about calls to the DeviceSetGpuOperationMode method.
		DeviceSetGpuOperationMode []struct {
			// Device is the device argument value.
			Device nvml.Device
			// GpuOperationMode is the gpuOperationMode argument value.
			GpuOperationMode nvml.GpuOperationMode
		}
		// DeviceSetMemClkVfOffset holds details about calls to the DeviceSetMemClkVfOffset method.
		DeviceSetMemClkVfOffset []struct {
			// Device is the device argument value.
			Device nvml.Device
			// N is the n argument value.
			N int
		}
		// DeviceSetMemoryLockedClocks holds details about calls to the DeviceSetMemoryLockedClocks method.
		DeviceSetMemoryLockedClocks []struct {
			// Device is the device argument value.
			Device nvml.Device
			// V1 is the v1 argument value.
			V1 uint32
			// V2 is the v2 argument value.
			V2 uint32
		}
		// DeviceSetMigMode holds details about calls to the DeviceSetMigMode method.
		DeviceSetMigMode []struct {
			// Device is the device argument value.
			Device nvml.Device
			// N is the n argument value.
			N int
		}
		// DeviceSetNvLinkDeviceLowPowerThreshold holds details about calls to the DeviceSetNvLinkDeviceLowPowerThreshold method.
		DeviceSetNvLinkDeviceLowPowerThreshold []struct {
			// Device is the device argument value.
			Device nvml.Device
			// NvLinkPowerThres is the nvLinkPowerThres argument value.
			NvLinkPowerThres *nvml.NvLinkPowerThres
		}
		// DeviceSetNvLinkUtilizationControl holds details about calls to the DeviceSetNvLinkUtilizationControl method.
		DeviceSetNvLinkUtilizationControl []struct {
			// Device is the device argument value.
			Device nvml.Device
			// N1 is the n1 argument value.
			N1 int
			// N2 is the n2 argument value.
			N2 int
			// NvLinkUtilizationControl is the nvLinkUtilizationControl argument value.
			NvLinkUtilizationControl *nvml.NvLinkUtilizationControl
			// B is the b argument value.
			B bool
		}
		// DeviceSetNvlinkBwMode holds details about calls to the DeviceSetNvlinkBwMode method.
		DeviceSetNvlinkBwMode []struct {
			// Device is the device argument value.
			Device nvml.Device
			// NvlinkSetBwMode is the nvlinkSetBwMode argument value.
			NvlinkSetBwMode *nvml.NvlinkSetBwMode
		}
		// DeviceSetPersistenceMode holds details about calls to the DeviceSetPersistenceMode method.
		DeviceSetPersistenceMode []struct {
			// Device is the device argument value.
			Device nvml.Device
			// EnableState is the enableState argument value.
			EnableState nvml.EnableState
		}
		// DeviceSetPowerManagementLimit holds details about calls to the DeviceSetPowerManagementLimit method.
		DeviceSetPowerManagementLimit []struct {
			// Device is the device argument value.
			Device nvml.Device
			// V is the v argument value.
			V uint32
		}
		// DeviceSetPowerManagementLimit_v2 holds details about calls to the DeviceSetPowerManagementLimit_v2 method.
		DeviceSetPowerManagementLimit_v2 []struct {
			// Device is the device argument value.
			Device nvml.Device
			// PowerValue_v2 is the powerValue_v2 argument value.
			PowerValue_v2 *nvml.PowerValue_v2
		}
		// DeviceSetTemperatureThreshold holds details about calls to the DeviceSetTemperatureThreshold method.
		DeviceSetTemperatureThreshold []struct {
			// Device is the device argument value.
			Device nvml.Device
			// TemperatureThresholds is the temperatureThresholds argument value.
			TemperatureThresholds nvml.TemperatureThresholds
			// N is the n argument value.
			N int
		}
		// DeviceSetVgpuCapabilities holds details about calls to the DeviceSetVgpuCapabilities method.
		DeviceSetVgpuCapabilities []struct {
			// Device is the device argument value.
			Device nvml.Device
			// DeviceVgpuCapability is the deviceVgpuCapability argument value.
			DeviceVgpuCapability nvml.DeviceVgpuCapability
			// EnableState is the enableState argument value.
			EnableState nvml.EnableState
		}
		// DeviceSetVgpuHeterogeneousMode holds details about calls to the DeviceSetVgpuHeterogeneousMode method.
		DeviceSetVgpuHeterogeneousMode []struct {
			// Device is the device argument value.
			Device nvml.Device
			// VgpuHeterogeneousMode is the vgpuHeterogeneousMode argument value.
			VgpuHeterogeneousMode nvml.VgpuHeterogeneousMode
		}
		// DeviceSetVgpuSchedulerState holds details about calls to the DeviceSetVgpuSchedulerState method.
		DeviceSetVgpuSchedulerState []struct {
			// Device is the device argument value.
			Device nvml.Device
			// VgpuSchedulerSetState is the vgpuSchedulerSetState argument value.
			VgpuSchedulerSetState *nvml.VgpuSchedulerSetState
		}
		// DeviceSetVirtualizationMode holds details about calls to the DeviceSetVirtualizationMode method.
		DeviceSetVirtualizationMode []struct {
			// Device is the device argument value.
			Device nvml.Device
			// GpuVirtualizationMode is the gpuVirtualizationMode argument value.
			GpuVirtualizationMode nvml.GpuVirtualizationMode
		}
		// DeviceValidateInforom holds details about calls to the DeviceValidateInforom method.
		DeviceValidateInforom []struct {
			// Device is the device argument value.
			Device nvml.Device
		}
		// DeviceWorkloadPowerProfileClearRequestedProfiles holds details about calls to the DeviceWorkloadPowerProfileClearRequestedProfiles method.
		DeviceWorkloadPowerProfileClearRequestedProfiles []struct {
			// Device is the device argument value.
			Device nvml.Device
			// WorkloadPowerProfileRequestedProfiles is the workloadPowerProfileRequestedProfiles argument value.
			WorkloadPowerProfileRequestedProfiles *nvml.WorkloadPowerProfileRequestedProfiles
		}
		// DeviceWorkloadPowerProfileGetCurrentProfiles holds details about calls to the DeviceWorkloadPowerProfileGetCurrentProfiles method.
		DeviceWorkloadPowerProfileGetCurrentProfiles []struct {
			// Device is the device argument value.
			Device nvml.Device
		}
		// DeviceWorkloadPowerProfileGetProfilesInfo holds details about calls to the DeviceWorkloadPowerProfileGetProfilesInfo method.
		DeviceWorkloadPowerProfileGetProfilesInfo []struct {
			// Device is the device argument value.
			Device nvml.Device
		}
		// DeviceWorkloadPowerProfileSetRequestedProfiles holds details about calls to the DeviceWorkloadPowerProfileSetRequestedProfiles method.
		DeviceWorkloadPowerProfileSetRequestedProfiles []struct {
			// Device is the device argument value.
			Device nvml.Device
			// WorkloadPowerProfileRequestedProfiles is the workloadPowerProfileRequestedProfiles argument value.
			WorkloadPowerProfileRequestedProfiles *nvml.WorkloadPowerProfileRequestedProfiles
		}
		// ErrorString holds details about calls to the ErrorString method.
		ErrorString []struct {
			// ReturnMoqParam is the returnMoqParam argument value.
			ReturnMoqParam nvml.Return
		}
		// EventSetCreate holds details about calls to the EventSetCreate method.
		EventSetCreate []struct {
		}
		// EventSetFree holds details about calls to the EventSetFree method.
		EventSetFree []struct {
			// EventSet is the eventSet argument value.
			EventSet nvml.EventSet
		}
		// EventSetWait holds details about calls to the EventSetWait method.
		EventSetWait []struct {
			// EventSet is the eventSet argument value.
			EventSet nvml.EventSet
			// V is the v argument value.
			V uint32
		}
		// Extensions holds details about calls to the Extensions method.
		Extensions []struct {
		}
		// GetExcludedDeviceCount holds details about calls to the GetExcludedDeviceCount method.
		GetExcludedDeviceCount []struct {
		}
		// GetExcludedDeviceInfoByIndex holds details about calls to the GetExcludedDeviceInfoByIndex method.
		GetExcludedDeviceInfoByIndex []struct {
			// N is the n argument value.
			N int
		}
		// GetVgpuCompatibility holds details about calls to the GetVgpuCompatibility method.
		GetVgpuCompatibility []struct {
			// VgpuMetadata is the vgpuMetadata argument value.
			VgpuMetadata *nvml.VgpuMetadata
			// VgpuPgpuMetadata is the vgpuPgpuMetadata argument value.
			VgpuPgpuMetadata *nvml.VgpuPgpuMetadata
		}
		// GetVgpuDriverCapabilities holds details about calls to the GetVgpuDriverCapabilities method.
		GetVgpuDriverCapabilities []struct {
			// VgpuDriverCapability is the vgpuDriverCapability argument value.
			VgpuDriverCapability nvml.VgpuDriverCapability
		}
		// GetVgpuVersion holds details about calls to the GetVgpuVersion method.
		GetVgpuVersion []struct {
		}
		// GpmMetricsGet holds details about calls to the GpmMetricsGet method.
		GpmMetricsGet []struct {
			// GpmMetricsGetType is the gpmMetricsGetType argument value.
			GpmMetricsGetType *nvml.GpmMetricsGetType
		}
		// GpmMetricsGetV holds details about calls to the GpmMetricsGetV method.
		GpmMetricsGetV []struct {
			// GpmMetricsGetType is the gpmMetricsGetType argument value.
			GpmMetricsGetType *nvml.GpmMetricsGetType
		}
		// GpmMigSampleGet holds details about calls to the GpmMigSampleGet method.
		GpmMigSampleGet []struct {
			// Device is the device argument value.
			Device nvml.Device
			// N is the n argument value.
			N int
			// GpmSample is the gpmSample argument value.
			GpmSample nvml.GpmSample
		}
		// GpmQueryDeviceSupport holds details about calls to the GpmQueryDeviceSupport method.
		GpmQueryDeviceSupport []struct {
			// Device is the device argument value.
			Device nvml.Device
		}
		// GpmQueryDeviceSupportV holds details about calls to the GpmQueryDeviceSupportV method.
		GpmQueryDeviceSupportV []struct {
			// Device is the device argument value.
			Device nvml.Device
		}
		// GpmQueryIfStreamingEnabled holds details about calls to the GpmQueryIfStreamingEnabled method.
		GpmQueryIfStreamingEnabled []struct {
			// Device is the device argument value.
			Device nvml.Device
		}
		// GpmSampleAlloc holds details about calls to the GpmSampleAlloc method.
		GpmSampleAlloc []struct {
		}
		// GpmSampleFree holds details about calls to the GpmSampleFree method.
		GpmSampleFree []struct {
			// GpmSample is the gpmSample argument value.
			GpmSample nvml.GpmSample
		}
		// GpmSampleGet holds details about calls to the GpmSampleGet method.
		GpmSampleGet []struct {
			// Device is the device argument value.
			Device nvml.Device
			// GpmSample is the gpmSample argument value.
			GpmSample nvml.GpmSample
		}
		// GpmSetStreamingEnabled holds details about calls to the GpmSetStreamingEnabled method.
		GpmSetStreamingEnabled []struct {
			// Device is the device argument value.
			Device nvml.Device
			// V is the v argument value.
			V uint32
		}
		// GpuInstanceCreateComputeInstance holds details about calls to the GpuInstanceCreateComputeInstance method.
		GpuInstanceCreateComputeInstance []struct {
			// GpuInstance is the gpuInstance argument value.
			GpuInstance nvml.GpuInstance
			// ComputeInstanceProfileInfo is the computeInstanceProfileInfo argument value.
			ComputeInstanceProfileInfo *nvml.ComputeInstanceProfileInfo
		}
		// GpuInstanceCreateComputeInstanceWithPlacement holds details about calls to the GpuInstanceCreateComputeInstanceWithPlacement method.
		GpuInstanceCreateComputeInstanceWithPlacement []struct {
			// GpuInstance is the gpuInstance argument value.
			GpuInstance nvml.GpuInstance
			// ComputeInstanceProfileInfo is the computeInstanceProfileInfo argument value.
			ComputeInstanceProfileInfo *nvml.ComputeInstanceProfileInfo
			// ComputeInstancePlacement is the computeInstancePlacement argument value.
			ComputeInstancePlacement *nvml.ComputeInstancePlacement
		}
		// GpuInstanceDestroy holds details about calls to the GpuInstanceDestroy method.
		GpuInstanceDestroy []struct {
			// GpuInstance is the gpuInstance argument value.
			GpuInstance nvml.GpuInstance
		}
		// GpuInstanceGetActiveVgpus holds details about calls to the GpuInstanceGetActiveVgpus method.
		GpuInstanceGetActiveVgpus []struct {
			// GpuInstance is the gpuInstance argument value.
			GpuInstance nvml.GpuInstance
		}
		// GpuInstanceGetComputeInstanceById holds details about calls to the GpuInstanceGetComputeInstanceById method.
		GpuInstanceGetComputeInstanceById []struct {
			// GpuInstance is the gpuInstance argument value.
			GpuInstance nvml.GpuInstance
			// N is the n argument value.
			N int
		}
		// GpuInstanceGetComputeInstancePossiblePlacements holds details about calls to the GpuInstanceGetComputeInstancePossiblePlacements method.
		GpuInstanceGetComputeInstancePossiblePlacements []struct {
			// GpuInstance is the gpuInstance argument value.
			GpuInstance nvml.GpuInstance
			// ComputeInstanceProfileInfo is the computeInstanceProfileInfo argument value.
			ComputeInstanceProfileInfo *nvml.ComputeInstanceProfileInfo
		}
		// GpuInstanceGetComputeInstanceProfileInfo holds details about calls to the GpuInstanceGetComputeInstanceProfileInfo method.
		GpuInstanceGetComputeInstanceProfileInfo []struct {
			// GpuInstance is the gpuInstance argument value.
			GpuInstance nvml.GpuInstance
			// N1 is the n1 argument value.
			N1 int
			// N2 is the n2 argument value.
			N2 int
		}
		// GpuInstanceGetComputeInstanceProfileInfoV holds details about calls to the GpuInstanceGetComputeInstanceProfileInfoV method.
		GpuInstanceGetComputeInstanceProfileInfoV []struct {
			// GpuInstance is the gpuInstance argument value.
			GpuInstance nvml.GpuInstance
			// N1 is the n1 argument value.
			N1 int
			// N2 is the n2 argument value.
			N2 int
		}
		// GpuInstanceGetComputeInstanceRemainingCapacity holds details about calls to the GpuInstanceGetComputeInstanceRemainingCapacity method.
		GpuInstanceGetComputeInstanceRemainingCapacity []struct {
			// GpuInstance is the gpuInstance argument value.
			GpuInstance nvml.GpuInstance
			// ComputeInstanceProfileInfo is the computeInstanceProfileInfo argument value.
			ComputeInstanceProfileInfo *nvml.ComputeInstanceProfileInfo
		}
		// GpuInstanceGetComputeInstances holds details about calls to the GpuInstanceGetComputeInstances method.
		GpuInstanceGetComputeInstances []struct {
			// GpuInstance is the gpuInstance argument value.
			GpuInstance nvml.GpuInstance
			// ComputeInstanceProfileInfo is the computeInstanceProfileInfo argument value.
			ComputeInstanceProfileInfo *nvml.ComputeInstanceProfileInfo
		}
		// GpuInstanceGetCreatableVgpus holds details about calls to the GpuInstanceGetCreatableVgpus method.
		GpuInstanceGetCreatableVgpus []struct {
			// GpuInstance is the gpuInstance argument value.
			GpuInstance nvml.GpuInstance
		}
		// GpuInstanceGetInfo holds details about calls to the GpuInstanceGetInfo method.
		GpuInstanceGetInfo []struct {
			// GpuInstance is the gpuInstance argument value.
			GpuInstance nvml.GpuInstance
		}
		// GpuInstanceGetVgpuHeterogeneousMode holds details about calls to the GpuInstanceGetVgpuHeterogeneousMode method.
		GpuInstanceGetVgpuHeterogeneousMode []struct {
			// GpuInstance is the gpuInstance argument value.
			GpuInstance nvml.GpuInstance
		}
		// GpuInstanceGetVgpuSchedulerLog holds details about calls to the GpuInstanceGetVgpuSchedulerLog method.
		GpuInstanceGetVgpuSchedulerLog []struct {
			// GpuInstance is the gpuInstance argument value.
			GpuInstance nvml.GpuInstance
		}
		// GpuInstanceGetVgpuSchedulerState holds details about calls to the GpuInstanceGetVgpuSchedulerState method.
		GpuInstanceGetVgpuSchedulerState []struct {
			// GpuInstance is the gpuInstance argument value.
			GpuInstance nvml.GpuInstance
		}
		// GpuInstanceGetVgpuTypeCreatablePlacements holds details about calls to the GpuInstanceGetVgpuTypeCreatablePlacements method.
		GpuInstanceGetVgpuTypeCreatablePlacements []struct {
			// GpuInstance is the gpuInstance argument value.
			GpuInstance nvml.GpuInstance
		}
		// GpuInstanceSetVgpuHeterogeneousMode holds details about calls to the GpuInstanceSetVgpuHeterogeneousMode method.
		GpuInstanceSetVgpuHeterogeneousMode []struct {
			// GpuInstance is the gpuInstance argument value.
			GpuInstance nvml.GpuInstance
			// VgpuHeterogeneousMode is the vgpuHeterogeneousMode argument value.
			VgpuHeterogeneousMode *nvml.VgpuHeterogeneousMode
		}
		// GpuInstanceSetVgpuSchedulerState holds details about calls to the GpuInstanceSetVgpuSchedulerState method.
		GpuInstanceSetVgpuSchedulerState []struct {
			// GpuInstance is the gpuInstance argument value.
			GpuInstance nvml.GpuInstance
			// VgpuSchedulerState is the vgpuSchedulerState argument value.
			VgpuSchedulerState *nvml.VgpuSchedulerState
		}
		// Init holds details about calls to the Init method.
		Init []struct {
		}
		// InitWithFlags holds details about calls to the InitWithFlags method.
		InitWithFlags []struct {
			// V is the v argument value.
			V uint32
		}
		// SetVgpuVersion holds details about calls to the SetVgpuVersion method.
		SetVgpuVersion []struct {
			// VgpuVersion is the vgpuVersion argument value.
			VgpuVersion *nvml.VgpuVersion
		}
		// Shutdown holds details about calls to the Shutdown method.
		Shutdown []struct {
		}
		// SystemEventSetCreate holds details about calls to the SystemEventSetCreate method.
		SystemEventSetCreate []struct {
			// SystemEventSetCreateRequest is the systemEventSetCreateRequest argument value.
			SystemEventSetCreateRequest *nvml.SystemEventSetCreateRequest
		}
		// SystemEventSetFree holds details about calls to the SystemEventSetFree method.
		SystemEventSetFree []struct {
			// SystemEventSetFreeRequest is the systemEventSetFreeRequest argument value.
			SystemEventSetFreeRequest *nvml.SystemEventSetFreeRequest
		}
		// SystemEventSetWait holds details about calls to the SystemEventSetWait method.
		SystemEventSetWait []struct {
			// SystemEventSetWaitRequest is the systemEventSetWaitRequest argument value.
			SystemEventSetWaitRequest *nvml.SystemEventSetWaitRequest
		}
		// SystemGetConfComputeCapabilities holds details about calls to the SystemGetConfComputeCapabilities method.
		SystemGetConfComputeCapabilities []struct {
		}
		// SystemGetConfComputeGpusReadyState holds details about calls to the SystemGetConfComputeGpusReadyState method.
		SystemGetConfComputeGpusReadyState []struct {
		}
		// SystemGetConfComputeKeyRotationThresholdInfo holds details about calls to the SystemGetConfComputeKeyRotationThresholdInfo method.
		SystemGetConfComputeKeyRotationThresholdInfo []struct {
		}
		// SystemGetConfComputeSettings holds details about calls to the SystemGetConfComputeSettings method.
		SystemGetConfComputeSettings []struct {
		}
		// SystemGetConfComputeState holds details about calls to the SystemGetConfComputeState method.
		SystemGetConfComputeState []struct {
		}
		// SystemGetCudaDriverVersion holds details about calls to the SystemGetCudaDriverVersion method.
		SystemGetCudaDriverVersion []struct {
		}
		// SystemGetCudaDriverVersion_v2 holds details about calls to the SystemGetCudaDriverVersion_v2 method.
		SystemGetCudaDriverVersion_v2 []struct {
		}
		// SystemGetDriverBranch holds details about calls to the SystemGetDriverBranch method.
		SystemGetDriverBranch []struct {
		}
		// SystemGetDriverVersion holds details about calls to the SystemGetDriverVersion method.
		SystemGetDriverVersion []struct {
		}
		// SystemGetHicVersion holds details about calls to the SystemGetHicVersion method.
		SystemGetHicVersion []struct {
		}
		// SystemGetNVMLVersion holds details about calls to the SystemGetNVMLVersion method.
		SystemGetNVMLVersion []struct {
		}
		// SystemGetNvlinkBwMode holds details about calls to the SystemGetNvlinkBwMode method.
		SystemGetNvlinkBwMode []struct {
		}
		// SystemGetProcessName holds details about calls to the SystemGetProcessName method.
		SystemGetProcessName []struct {
			// N is the n argument value.
			N int
		}
		// SystemGetTopologyGpuSet holds details about calls to the SystemGetTopologyGpuSet method.
		SystemGetTopologyGpuSet []struct {
			// N is the n argument value.
			N int
		}
		// SystemRegisterEvents holds details about calls to the SystemRegisterEvents method.
		SystemRegisterEvents []struct {
			// SystemRegisterEventRequest is the systemRegisterEventRequest argument value.
			SystemRegisterEventRequest *nvml.SystemRegisterEventRequest
		}
		// SystemSetConfComputeGpusReadyState holds details about calls to the SystemSetConfComputeGpusReadyState method.
		SystemSetConfComputeGpusReadyState []struct {
			// V is the v argument value.
			V uint32
		}
		// SystemSetConfComputeKeyRotationThresholdInfo holds details about calls to the SystemSetConfComputeKeyRotationThresholdInfo method.
		SystemSetConfComputeKeyRotationThresholdInfo []struct {
			// ConfComputeSetKeyRotationThresholdInfo is the confComputeSetKeyRotationThresholdInfo argument value.
			ConfComputeSetKeyRotationThresholdInfo nvml.ConfComputeSetKeyRotationThresholdInfo
		}
		// SystemSetNvlinkBwMode holds details about calls to the SystemSetNvlinkBwMode method.
		SystemSetNvlinkBwMode []struct {
			// V is the v argument value.
			V uint32
		}
		// UnitGetCount holds details about calls to the UnitGetCount method.
		UnitGetCount []struct {
		}
		// UnitGetDevices holds details about calls to the UnitGetDevices method.
		UnitGetDevices []struct {
			// Unit is the unit argument value.
			Unit nvml.Unit
		}
		// UnitGetFanSpeedInfo holds details about calls to the UnitGetFanSpeedInfo method.
		UnitGetFanSpeedInfo []struct {
			// Unit is the unit argument value.
			Unit nvml.Unit
		}
		// UnitGetHandleByIndex holds details about calls to the UnitGetHandleByIndex method.
		UnitGetHandleByIndex []struct {
			// N is the n argument value.
			N int
		}
		// UnitGetLedState holds details about calls to the UnitGetLedState method.
		UnitGetLedState []struct {
			// Unit is the unit argument value.
			Unit nvml.Unit
		}
		// UnitGetPsuInfo holds details about calls to the UnitGetPsuInfo method.
		UnitGetPsuInfo []struct {
			// Unit is the unit argument value.
			Unit nvml.Unit
		}
		// UnitGetTemperature holds details about calls to the UnitGetTemperature method.
		UnitGetTemperature []struct {
			// Unit is the unit argument value.
			Unit nvml.Unit
			// N is the n argument value.
			N int
		}
		// UnitGetUnitInfo holds details about calls to the UnitGetUnitInfo method.
		UnitGetUnitInfo []struct {
			// Unit is the unit argument value.
			Unit nvml.Unit
		}
		// UnitSetLedState holds details about calls to the UnitSetLedState method.
		UnitSetLedState []struct {
			// Unit is the unit argument value.
			Unit nvml.Unit
			// LedColor is the ledColor argument value.
			LedColor nvml.LedColor
		}
		// VgpuInstanceClearAccountingPids holds details about calls to the VgpuInstanceClearAccountingPids method.
		VgpuInstanceClearAccountingPids []struct {
			// VgpuInstance is the vgpuInstance argument value.
			VgpuInstance nvml.VgpuInstance
		}
		// VgpuInstanceGetAccountingMode holds details about calls to the VgpuInstanceGetAccountingMode method.
		VgpuInstanceGetAccountingMode []struct {
			// VgpuInstance is the vgpuInstance argument value.
			VgpuInstance nvml.VgpuInstance
		}
		// VgpuInstanceGetAccountingPids holds details about calls to the VgpuInstanceGetAccountingPids method.
		VgpuInstanceGetAccountingPids []struct {
			// VgpuInstance is the vgpuInstance argument value.
			VgpuInstance nvml.VgpuInstance
		}
		// VgpuInstanceGetAccountingStats holds details about calls to the VgpuInstanceGetAccountingStats method.
		VgpuInstanceGetAccountingStats []struct {
			// VgpuInstance is the vgpuInstance argument value.
			VgpuInstance nvml.VgpuInstance
			// N is the n argument value.
			N int
		}
		// VgpuInstanceGetEccMode holds details about calls to the VgpuInstanceGetEccMode method.
		VgpuInstanceGetEccMode []struct {
			// VgpuInstance is the vgpuInstance argument value.
			VgpuInstance nvml.VgpuInstance
		}
		// VgpuInstanceGetEncoderCapacity holds details about calls to the VgpuInstanceGetEncoderCapacity method.
		VgpuInstanceGetEncoderCapacity []struct {
			// VgpuInstance is the vgpuInstance argument value.
			VgpuInstance nvml.VgpuInstance
		}
		// VgpuInstanceGetEncoderSessions holds details about calls to the VgpuInstanceGetEncoderSessions method.
		VgpuInstanceGetEncoderSessions []struct {
			// VgpuInstance is the vgpuInstance argument value.
			VgpuInstance nvml.VgpuInstance
		}
		// VgpuInstanceGetEncoderStats holds details about calls to the VgpuInstanceGetEncoderStats method.
		VgpuInstanceGetEncoderStats []struct {
			// VgpuInstance is the vgpuInstance argument value.
			VgpuInstance nvml.VgpuInstance
		}
		// VgpuInstanceGetFBCSessions holds details about calls to the VgpuInstanceGetFBCSessions method.
		VgpuInstanceGetFBCSessions []struct {
			// VgpuInstance is the vgpuInstance argument value.
			VgpuInstance nvml.VgpuInstance
		}
		// VgpuInstanceGetFBCStats holds details about calls to the VgpuInstanceGetFBCStats method.
		VgpuInstanceGetFBCStats []struct {
			// VgpuInstance is the vgpuInstance argument value.
			VgpuInstance nvml.VgpuInstance
		}
		// VgpuInstanceGetFbUsage holds details about calls to the VgpuInstanceGetFbUsage method.
		VgpuInstanceGetFbUsage []struct {
			// VgpuInstance is the vgpuInstance argument value.
			VgpuInstance nvml.VgpuInstance
		}
		// VgpuInstanceGetFrameRateLimit holds details about calls to the VgpuInstanceGetFrameRateLimit method.
		VgpuInstanceGetFrameRateLimit []struct {
			// VgpuInstance is the vgpuInstance argument value.
			VgpuInstance nvml.VgpuInstance
		}
		// VgpuInstanceGetGpuInstanceId holds details about calls to the VgpuInstanceGetGpuInstanceId method.
		VgpuInstanceGetGpuInstanceId []struct {
			// VgpuInstance is the vgpuInstance argument value.
			VgpuInstance nvml.VgpuInstance
		}
		// VgpuInstanceGetGpuPciId holds details about calls to the VgpuInstanceGetGpuPciId method.
		VgpuInstanceGetGpuPciId []struct {
			// VgpuInstance is the vgpuInstance argument value.
			VgpuInstance nvml.VgpuInstance
		}
		// VgpuInstanceGetLicenseInfo holds details about calls to the VgpuInstanceGetLicenseInfo method.
		VgpuInstanceGetLicenseInfo []struct {
			// VgpuInstance is the vgpuInstance argument value.
			VgpuInstance nvml.VgpuInstance
		}
		// VgpuInstanceGetLicenseStatus holds details about calls to the VgpuInstanceGetLicenseStatus method.
		VgpuInstanceGetLicenseStatus []struct {
			// VgpuInstance is the vgpuInstance argument value.
			VgpuInstance nvml.VgpuInstance
		}
		// VgpuInstanceGetMdevUUID holds details about calls to the VgpuInstanceGetMdevUUID method.
		VgpuInstanceGetMdevUUID []struct {
			// VgpuInstance is the vgpuInstance argument value.
			VgpuInstance nvml.VgpuInstance
		}
		// VgpuInstanceGetMetadata holds details about calls to the VgpuInstanceGetMetadata method.
		VgpuInstanceGetMetadata []struct {
			// VgpuInstance is the vgpuInstance argument value.
			VgpuInstance nvml.VgpuInstance
		}
		// VgpuInstanceGetRuntimeStateSize holds details about calls to the VgpuInstanceGetRuntimeStateSize method.
		VgpuInstanceGetRuntimeStateSize []struct {
			// VgpuInstance is the vgpuInstance argument value.
			VgpuInstance nvml.VgpuInstance
		}
		// VgpuInstanceGetType holds details about calls to the VgpuInstanceGetType method.
		VgpuInstanceGetType []struct {
			// VgpuInstance is the vgpuInstance argument value.
			VgpuInstance nvml.VgpuInstance
		}
		// VgpuInstanceGetUUID holds details about calls to the VgpuInstanceGetUUID method.
		VgpuInstanceGetUUID []struct {
			// VgpuInstance is the vgpuInstance argument value.
			VgpuInstance nvml.VgpuInstance
		}
		// VgpuInstanceGetVmDriverVersion holds details about calls to the VgpuInstanceGetVmDriverVersion method.
		VgpuInstanceGetVmDriverVersion []struct {
			// VgpuInstance is the vgpuInstance argument value.
			VgpuInstance nvml.VgpuInstance
		}
		// VgpuInstanceGetVmID holds details about calls to the VgpuInstanceGetVmID method.
		VgpuInstanceGetVmID []struct {
			// VgpuInstance is the vgpuInstance argument value.
			VgpuInstance nvml.VgpuInstance
		}
		// VgpuInstanceSetEncoderCapacity holds details about calls to the VgpuInstanceSetEncoderCapacity method.
		VgpuInstanceSetEncoderCapacity []struct {
			// VgpuInstance is the vgpuInstance argument value.
			VgpuInstance nvml.VgpuInstance
			// N is the n argument value.
			N int
		}
		// VgpuTypeGetBAR1Info holds details about calls to the VgpuTypeGetBAR1Info method.
		VgpuTypeGetBAR1Info []struct {
			// VgpuTypeId is the vgpuTypeId argument value.
			VgpuTypeId nvml.VgpuTypeId
		}
		// VgpuTypeGetCapabilities holds details about calls to the VgpuTypeGetCapabilities method.
		VgpuTypeGetCapabilities []struct {
			// VgpuTypeId is the vgpuTypeId argument value.
			VgpuTypeId nvml.VgpuTypeId
			// VgpuCapability is the vgpuCapability argument value.
			VgpuCapability nvml.VgpuCapability
		}
		// VgpuTypeGetClass holds details about calls to the VgpuTypeGetClass method.
		VgpuTypeGetClass []struct {
			// VgpuTypeId is the vgpuTypeId argument value.
			VgpuTypeId nvml.VgpuTypeId
		}
		// VgpuTypeGetDeviceID holds details about calls to the VgpuTypeGetDeviceID method.
		VgpuTypeGetDeviceID []struct {
			// VgpuTypeId is the vgpuTypeId argument value.
			VgpuTypeId nvml.VgpuTypeId
		}
		// VgpuTypeGetFrameRateLimit holds details about calls to the VgpuTypeGetFrameRateLimit method.
		VgpuTypeGetFrameRateLimit []struct {
			// VgpuTypeId is the vgpuTypeId argument value.
			VgpuTypeId nvml.VgpuTypeId
		}
		// VgpuTypeGetFramebufferSize holds details about calls to the VgpuTypeGetFramebufferSize method.
		VgpuTypeGetFramebufferSize []struct {
			// VgpuTypeId is the vgpuTypeId argument value.
			VgpuTypeId nvml.VgpuTypeId
		}
		// VgpuTypeGetGpuInstanceProfileId holds details about calls to the VgpuTypeGetGpuInstanceProfileId method.
		VgpuTypeGetGpuInstanceProfileId []struct {
			// VgpuTypeId is the vgpuTypeId argument value.
			VgpuTypeId nvml.VgpuTypeId
		}
		// VgpuTypeGetLicense holds details about calls to the VgpuTypeGetLicense method.
		VgpuTypeGetLicense []struct {
			// VgpuTypeId is the vgpuTypeId argument value.
			VgpuTypeId nvml.VgpuTypeId
		}
		// VgpuTypeGetMaxInstances holds details about calls to the VgpuTypeGetMaxInstances method.
		VgpuTypeGetMaxInstances []struct {
			// Device is the device argument value.
			Device nvml.Device
			// VgpuTypeId is the vgpuTypeId argument value.
			VgpuTypeId nvml.VgpuTypeId
		}
		// VgpuTypeGetMaxInstancesPerGpuInstance holds details about calls to the VgpuTypeGetMaxInstancesPerGpuInstance method.
		VgpuTypeGetMaxInstancesPerGpuInstance []struct {
			// VgpuTypeMaxInstance is the vgpuTypeMaxInstance argument value.
			VgpuTypeMaxInstance *nvml.VgpuTypeMaxInstance
		}
		// VgpuTypeGetMaxInstancesPerVm holds details about calls to the VgpuTypeGetMaxInstancesPerVm method.
		VgpuTypeGetMaxInstancesPerVm []struct {
			// VgpuTypeId is the vgpuTypeId argument value.
			VgpuTypeId nvml.VgpuTypeId
		}
		// VgpuTypeGetName holds details about calls to the VgpuTypeGetName method.
		VgpuTypeGetName []struct {
			// VgpuTypeId is the vgpuTypeId argument value.
			VgpuTypeId nvml.VgpuTypeId
		}
		// VgpuTypeGetNumDisplayHeads holds details about calls to the VgpuTypeGetNumDisplayHeads method.
		VgpuTypeGetNumDisplayHeads []struct {
			// VgpuTypeId is the vgpuTypeId argument value.
			VgpuTypeId nvml.VgpuTypeId
		}
		// VgpuTypeGetResolution holds details about calls to the VgpuTypeGetResolution method.
		VgpuTypeGetResolution []struct {
			// VgpuTypeId is the vgpuTypeId argument value.
			VgpuTypeId nvml.VgpuTypeId
			// N is the n argument value.
			N int
		}
	}
	lockComputeInstanceDestroy                           sync.RWMutex
	lockComputeInstanceGetInfo                           sync.RWMutex
	lockDeviceClearAccountingPids                        sync.RWMutex
	lockDeviceClearCpuAffinity                           sync.RWMutex
	lockDeviceClearEccErrorCounts                        sync.RWMutex
	lockDeviceClearFieldValues                           sync.RWMutex
	lockDeviceCreateGpuInstance                          sync.RWMutex
	lockDeviceCreateGpuInstanceWithPlacement             sync.RWMutex
	lockDeviceDiscoverGpus                               sync.RWMutex
	lockDeviceFreezeNvLinkUtilizationCounter             sync.RWMutex
	lockDeviceGetAPIRestriction                          sync.RWMutex
	lockDeviceGetAccountingBufferSize                    sync.RWMutex
	lockDeviceGetAccountingMode                          sync.RWMutex
	lockDeviceGetAccountingPids                          sync.RWMutex
	lockDeviceGetAccountingStats                         sync.RWMutex
	lockDeviceGetActiveVgpus                             sync.RWMutex
	lockDeviceGetAdaptiveClockInfoStatus                 sync.RWMutex
	lockDeviceGetAddressingMode                          sync.RWMutex
	lockDeviceGetApplicationsClock                       sync.RWMutex
	lockDeviceGetArchitecture                            sync.RWMutex
	lockDeviceGetAttributes                              sync.RWMutex
	lockDeviceGetAutoBoostedClocksEnabled                sync.RWMutex
	lockDeviceGetBAR1MemoryInfo                          sync.RWMutex
	lockDeviceGetBoardId                                 sync.RWMutex
	lockDeviceGetBoardPartNumber                         sync.RWMutex
	lockDeviceGetBrand                                   sync.RWMutex
	lockDeviceGetBridgeChipInfo                          sync.RWMutex
	lockDeviceGetBusType                                 sync.RWMutex
	lockDeviceGetC2cModeInfoV                            sync.RWMutex
	lockDeviceGetCapabilities                            sync.RWMutex
	lockDeviceGetClkMonStatus                            sync.RWMutex
	lockDeviceGetClock                                   sync.RWMutex
	lockDeviceGetClockInfo                               sync.RWMutex
	lockDeviceGetClockOffsets                            sync.RWMutex
	lockDeviceGetComputeInstanceId                       sync.RWMutex
	lockDeviceGetComputeMode                             sync.RWMutex
	lockDeviceGetComputeRunningProcesses                 sync.RWMutex
	lockDeviceGetConfComputeGpuAttestationReport         sync.RWMutex
	lockDeviceGetConfComputeGpuCertificate               sync.RWMutex
	lockDeviceGetConfComputeMemSizeInfo                  sync.RWMutex
	lockDeviceGetConfComputeProtectedMemoryUsage         sync.RWMutex
	lockDeviceGetCoolerInfo                              sync.RWMutex
	lockDeviceGetCount                                   sync.RWMutex
	lockDeviceGetCpuAffinity                             sync.RWMutex
	lockDeviceGetCpuAffinityWithinScope                  sync.RWMutex
	lockDeviceGetCreatableVgpus                          sync.RWMutex
	lockDeviceGetCudaComputeCapability                   sync.RWMutex
	lockDeviceGetCurrPcieLinkGeneration                  sync.RWMutex
	lockDeviceGetCurrPcieLinkWidth                       sync.RWMutex
	lockDeviceGetCurrentClockFreqs                       sync.RWMutex
	lockDeviceGetCurrentClocksEventReasons               sync.RWMutex
	lockDeviceGetCurrentClocksThrottleReasons            sync.RWMutex
	lockDeviceGetDecoderUtilization                      sync.RWMutex
	lockDeviceGetDefaultApplicationsClock                sync.RWMutex
	lockDeviceGetDefaultEccMode                          sync.RWMutex
	lockDeviceGetDetailedEccErrors                       sync.RWMutex
	lockDeviceGetDeviceHandleFromMigDeviceHandle         sync.RWMutex
	lockDeviceGetDisplayActive                           sync.RWMutex
	lockDeviceGetDisplayMode                             sync.RWMutex
	lockDeviceGetDramEncryptionMode                      sync.RWMutex
	lockDeviceGetDriverModel                             sync.RWMutex
	lockDeviceGetDriverModel_v2                          sync.RWMutex
	lockDeviceGetDynamicPstatesInfo                      sync.RWMutex
	lockDeviceGetEccMode                                 sync.RWMutex
	lockDeviceGetEncoderCapacity                         sync.RWMutex
	lockDeviceGetEncoderSessions                         sync.RWMutex
	lockDeviceGetEncoderStats                            sync.RWMutex
	lockDeviceGetEncoderUtilization                      sync.RWMutex
	lockDeviceGetEnforcedPowerLimit                      sync.RWMutex
	lockDeviceGetFBCSessions                             sync.RWMutex
	lockDeviceGetFBCStats                                sync.RWMutex
	lockDeviceGetFanControlPolicy_v2                     sync.RWMutex
	lockDeviceGetFanSpeed                                sync.RWMutex
	lockDeviceGetFanSpeedRPM                             sync.RWMutex
	lockDeviceGetFanSpeed_v2                             sync.RWMutex
	lockDeviceGetFieldValues                             sync.RWMutex
	lockDeviceGetGpcClkMinMaxVfOffset                    sync.RWMutex
	lockDeviceGetGpcClkVfOffset                          sync.RWMutex
	lockDeviceGetGpuFabricInfo                           sync.RWMutex
	lockDeviceGetGpuFabricInfoV                          sync.RWMutex
	lockDeviceGetGpuInstanceById                         sync.RWMutex
	lockDeviceGetGpuInstanceId                           sync.RWMutex
	lockDeviceGetGpuInstancePossiblePlacements           sync.RWMutex
	lockDeviceGetGpuInstanceProfileInfo                  sync.RWMutex
	lockDeviceGetGpuInstanceProfileInfoByIdV             sync.RWMutex
	lockDeviceGetGpuInstanceProfileInfoV                 sync.RWMutex
	lockDeviceGetGpuInstanceRemainingCapacity            sync.RWMutex
	lockDeviceGetGpuInstances                            sync.RWMutex
	lockDeviceGetGpuMaxPcieLinkGeneration                sync.RWMutex
	lockDeviceGetGpuOperationMode                        sync.RWMutex
	lockDeviceGetGraphicsRunningProcesses                sync.RWMutex
	lockDeviceGetGridLicensableFeatures                  sync.RWMutex
	lockDeviceGetGspFirmwareMode                         sync.RWMutex
	lockDeviceGetGspFirmwareVersion                      sync.RWMutex
	lockDeviceGetHandleByIndex                           sync.RWMutex
	lockDeviceGetHandleByPciBusId                        sync.RWMutex
	lockDeviceGetHandleBySerial                          sync.RWMutex
	lockDeviceGetHandleByUUID                            sync.RWMutex
	lockDeviceGetHandleByUUIDV                           sync.RWMutex
	lockDeviceGetHostVgpuMode                            sync.RWMutex
	lockDeviceGetIndex                                   sync.RWMutex
	lockDeviceGetInforomConfigurationChecksum            sync.RWMutex
	lockDeviceGetInforomImageVersion                     sync.RWMutex
	lockDeviceGetInforomVersion                          sync.RWMutex
	lockDeviceGetIrqNum                                  sync.RWMutex
	lockDeviceGetJpgUtilization                          sync.RWMutex
	lockDeviceGetLastBBXFlushTime                        sync.RWMutex
	lockDeviceGetMPSComputeRunningProcesses              sync.RWMutex
	lockDeviceGetMarginTemperature                       sync.RWMutex
	lockDeviceGetMaxClockInfo                            sync.RWMutex
	lockDeviceGetMaxCustomerBoostClock                   sync.RWMutex
	lockDeviceGetMaxMigDeviceCount                       sync.RWMutex
	lockDeviceGetMaxPcieLinkGeneration                   sync.RWMutex
	lockDeviceGetMaxPcieLinkWidth                        sync.RWMutex
	lockDeviceGetMemClkMinMaxVfOffset                    sync.RWMutex
	lockDeviceGetMemClkVfOffset                          sync.RWMutex
	lockDeviceGetMemoryAffinity                          sync.RWMutex
	lockDeviceGetMemoryBusWidth                          sync.RWMutex
	lockDeviceGetMemoryErrorCounter                      sync.RWMutex
	lockDeviceGetMemoryInfo                              sync.RWMutex
	lockDeviceGetMemoryInfo_v2                           sync.RWMutex
	lockDeviceGetMigDeviceHandleByIndex                  sync.RWMutex
	lockDeviceGetMigMode                                 sync.RWMutex
	lockDeviceGetMinMaxClockOfPState                     sync.RWMutex
	lockDeviceGetMinMaxFanSpeed                          sync.RWMutex
	lockDeviceGetMinorNumber                             sync.RWMutex
	lockDeviceGetModuleId                                sync.RWMutex
	lockDeviceGetMultiGpuBoard                           sync.RWMutex
	lockDeviceGetName                                    sync.RWMutex
	lockDeviceGetNumFans                                 sync.RWMutex
	lockDeviceGetNumGpuCores                             sync.RWMutex
	lockDeviceGetNumaNodeId                              sync.RWMutex
	lockDeviceGetNvLinkCapability                        sync.RWMutex
	lockDeviceGetNvLinkErrorCounter                      sync.RWMutex
	lockDeviceGetNvLinkInfo                              sync.RWMutex
	lockDeviceGetNvLinkRemoteDeviceType                  sync.RWMutex
	lockDeviceGetNvLinkRemotePciInfo                     sync.RWMutex
	lockDeviceGetNvLinkState                             sync.RWMutex
	lockDeviceGetNvLinkUtilizationControl                sync.RWMutex
	lockDeviceGetNvLinkUtilizationCounter                sync.RWMutex
	lockDeviceGetNvLinkVersion                           sync.RWMutex
	lockDeviceGetNvlinkBwMode                            sync.RWMutex
	lockDeviceGetNvlinkSupportedBwModes                  sync.RWMutex
	lockDeviceGetOfaUtilization                          sync.RWMutex
	lockDeviceGetP2PStatus                               sync.RWMutex
	lockDeviceGetPciInfo                                 sync.RWMutex
	lockDeviceGetPciInfoExt                              sync.RWMutex
	lockDeviceGetPcieLinkMaxSpeed                        sync.RWMutex
	lockDeviceGetPcieReplayCounter                       sync.RWMutex
	lockDeviceGetPcieSpeed                               sync.RWMutex
	lockDeviceGetPcieThroughput                          sync.RWMutex
	lockDeviceGetPdi                                     sync.RWMutex
	lockDeviceGetPerformanceModes                        sync.RWMutex
	lockDeviceGetPerformanceState                        sync.RWMutex
	lockDeviceGetPersistenceMode                         sync.RWMutex
	lockDeviceGetPgpuMetadataString                      sync.RWMutex
	lockDeviceGetPlatformInfo                            sync.RWMutex
	lockDeviceGetPowerManagementDefaultLimit             sync.RWMutex
	lockDeviceGetPowerManagementLimit                    sync.RWMutex
	lockDeviceGetPowerManagementLimitConstraints         sync.RWMutex
	lockDeviceGetPowerManagementMode                     sync.RWMutex
	lockDeviceGetPowerMizerMode_v1                       sync.RWMutex
	lockDeviceGetPowerSource                             sync.RWMutex
	lockDeviceGetPowerState                              sync.RWMutex
	lockDeviceGetPowerUsage                              sync.RWMutex
	lockDeviceGetProcessUtilization                      sync.RWMutex
	lockDeviceGetProcessesUtilizationInfo                sync.RWMutex
	lockDeviceGetRemappedRows                            sync.RWMutex
	lockDeviceGetRepairStatus                            sync.RWMutex
	lockDeviceGetRetiredPages                            sync.RWMutex
	lockDeviceGetRetiredPagesPendingStatus               sync.RWMutex
	lockDeviceGetRetiredPages_v2                         sync.RWMutex
	lockDeviceGetRowRemapperHistogram                    sync.RWMutex
	lockDeviceGetRunningProcessDetailList                sync.RWMutex
	lockDeviceGetSamples                                 sync.RWMutex
	lockDeviceGetSerial                                  sync.RWMutex
	lockDeviceGetSramEccErrorStatus                      sync.RWMutex
	lockDeviceGetSramUniqueUncorrectedEccErrorCounts     sync.RWMutex
	lockDeviceGetSupportedClocksEventReasons             sync.RWMutex
	lockDeviceGetSupportedClocksThrottleReasons          sync.RWMutex
	lockDeviceGetSupportedEventTypes                     sync.RWMutex
	lockDeviceGetSupportedGraphicsClocks                 sync.RWMutex
	lockDeviceGetSupportedMemoryClocks                   sync.RWMutex
	lockDeviceGetSupportedPerformanceStates              sync.RWMutex
	lockDeviceGetSupportedVgpus                          sync.RWMutex
	lockDeviceGetTargetFanSpeed                          sync.RWMutex
	lockDeviceGetTemperature                             sync.RWMutex
	lockDeviceGetTemperatureThreshold                    sync.RWMutex
	lockDeviceGetTemperatureV                            sync.RWMutex
	lockDeviceGetThermalSettings                         sync.RWMutex
	lockDeviceGetTopologyCommonAncestor                  sync.RWMutex
	lockDeviceGetTopologyNearestGpus                     sync.RWMutex
	lockDeviceGetTotalEccErrors                          sync.RWMutex
	lockDeviceGetTotalEnergyConsumption                  sync.RWMutex
	lockDeviceGetUUID                                    sync.RWMutex
	lockDeviceGetUtilizationRates                        sync.RWMutex
	lockDeviceGetVbiosVersion                            sync.RWMutex
	lockDeviceGetVgpuCapabilities                        sync.RWMutex
	lockDeviceGetVgpuHeterogeneousMode                   sync.RWMutex
	lockDeviceGetVgpuInstancesUtilizationInfo            sync.RWMutex
	lockDeviceGetVgpuMetadata                            sync.RWMutex
	lockDeviceGetVgpuProcessUtilization                  sync.RWMutex
	lockDeviceGetVgpuProcessesUtilizationInfo            sync.RWMutex
	lockDeviceGetVgpuSchedulerCapabilities               sync.RWMutex
	lockDeviceGetVgpuSchedulerLog                        sync.RWMutex
	lockDeviceGetVgpuSchedulerState                      sync.RWMutex
	lockDeviceGetVgpuTypeCreatablePlacements             sync.RWMutex
	lockDeviceGetVgpuTypeSupportedPlacements             sync.RWMutex
	lockDeviceGetVgpuUtilization                         sync.RWMutex
	lockDeviceGetViolationStatus                         sync.RWMutex
	lockDeviceGetVirtualizationMode                      sync.RWMutex
	lockDeviceIsMigDeviceHandle                          sync.RWMutex
	lockDeviceModifyDrainState                           sync.RWMutex
	lockDeviceOnSameBoard                                sync.RWMutex
	lockDevicePowerSmoothingActivatePresetProfile        sync.RWMutex
	lockDevicePowerSmoothingSetState                     sync.RWMutex
	lockDevicePowerSmoothingUpdatePresetProfileParam     sync.RWMutex
	lockDeviceQueryDrainState                            sync.RWMutex
	lockDeviceReadWritePRM_v1                            sync.RWMutex
	lockDeviceRegisterEvents                             sync.RWMutex
	lockDeviceRemoveGpu                                  sync.RWMutex
	lockDeviceRemoveGpu_v2                               sync.RWMutex
	lockDeviceResetApplicationsClocks                    sync.RWMutex
	lockDeviceResetGpuLockedClocks                       sync.RWMutex
	lockDeviceResetMemoryLockedClocks                    sync.RWMutex
	lockDeviceResetNvLinkErrorCounters                   sync.RWMutex
	lockDeviceResetNvLinkUtilizationCounter              sync.RWMutex
	lockDeviceSetAPIRestriction                          sync.RWMutex
	lockDeviceSetAccountingMode                          sync.RWMutex
	lockDeviceSetApplicationsClocks                      sync.RWMutex
	lockDeviceSetAutoBoostedClocksEnabled                sync.RWMutex
	lockDeviceSetClockOffsets                            sync.RWMutex
	lockDeviceSetComputeMode                             sync.RWMutex
	lockDeviceSetConfComputeUnprotectedMemSize           sync.RWMutex
	lockDeviceSetCpuAffinity                             sync.RWMutex
	lockDeviceSetDefaultAutoBoostedClocksEnabled         sync.RWMutex
	lockDeviceSetDefaultFanSpeed_v2                      sync.RWMutex
	lockDeviceSetDramEncryptionMode                      sync.RWMutex
	lockDeviceSetDriverModel                             sync.RWMutex
	lockDeviceSetEccMode                                 sync.RWMutex
	lockDeviceSetFanControlPolicy                        sync.RWMutex
	lockDeviceSetFanSpeed_v2                             sync.RWMutex
	lockDeviceSetGpcClkVfOffset                          sync.RWMutex
	lockDeviceSetGpuLockedClocks                         sync.RWMutex
	lockDeviceSetGpuOperationMode                        sync.RWMutex
	lockDeviceSetMemClkVfOffset                          sync.RWMutex
	lockDeviceSetMemoryLockedClocks                      sync.RWMutex
	lockDeviceSetMigMode                                 sync.RWMutex
	lockDeviceSetNvLinkDeviceLowPowerThreshold           sync.RWMutex
	lockDeviceSetNvLinkUtilizationControl                sync.RWMutex
	lockDeviceSetNvlinkBwMode                            sync.RWMutex
	lockDeviceSetPersistenceMode                         sync.RWMutex
	lockDeviceSetPowerManagementLimit                    sync.RWMutex
	lockDeviceSetPowerManagementLimit_v2                 sync.RWMutex
	lockDeviceSetTemperatureThreshold                    sync.RWMutex
	lockDeviceSetVgpuCapabilities                        sync.RWMutex
	lockDeviceSetVgpuHeterogeneousMode                   sync.RWMutex
	lockDeviceSetVgpuSchedulerState                      sync.RWMutex
	lockDeviceSetVirtualizationMode                      sync.RWMutex
	lockDeviceValidateInforom                            sync.RWMutex
	lockDeviceWorkloadPowerProfileClearRequestedProfiles sync.RWMutex
	lockDeviceWorkloadPowerProfileGetCurrentProfiles     sync.RWMutex
	lockDeviceWorkloadPowerProfileGetProfilesInfo        sync.RWMutex
	lockDeviceWorkloadPowerProfileSetRequestedProfiles   sync.RWMutex
	lockErrorString                                      sync.RWMutex
	lockEventSetCreate                                   sync.RWMutex
	lockEventSetFree                                     sync.RWMutex
	lockEventSetWait                                     sync.RWMutex
	lockExtensions                                       sync.RWMutex
	lockGetExcludedDeviceCount                           sync.RWMutex
	lockGetExcludedDeviceInfoByIndex                     sync.RWMutex
	lockGetVgpuCompatibility                             sync.RWMutex
	lockGetVgpuDriverCapabilities                        sync.RWMutex
	lockGetVgpuVersion                                   sync.RWMutex
	lockGpmMetricsGet                                    sync.RWMutex
	lockGpmMetricsGetV                                   sync.RWMutex
	lockGpmMigSampleGet                                  sync.RWMutex
	lockGpmQueryDeviceSupport                            sync.RWMutex
	lockGpmQueryDeviceSupportV                           sync.RWMutex
	lockGpmQueryIfStreamingEnabled                       sync.RWMutex
	lockGpmSampleAlloc                                   sync.RWMutex
	lockGpmSampleFree                                    sync.RWMutex
	lockGpmSampleGet                                     sync.RWMutex
	lockGpmSetStreamingEnabled                           sync.RWMutex
	lockGpuInstanceCreateComputeInstance                 sync.RWMutex
	lockGpuInstanceCreateComputeInstanceWithPlacement    sync.RWMutex
	lockGpuInstanceDestroy                               sync.RWMutex
	lockGpuInstanceGetActiveVgpus                        sync.RWMutex
	lockGpuInstanceGetComputeInstanceById                sync.RWMutex
	lockGpuInstanceGetComputeInstancePossiblePlacements  sync.RWMutex
	lockGpuInstanceGetComputeInstanceProfileInfo         sync.RWMutex
	lockGpuInstanceGetComputeInstanceProfileInfoV        sync.RWMutex
	lockGpuInstanceGetComputeInstanceRemainingCapacity   sync.RWMutex
	lockGpuInstanceGetComputeInstances                   sync.RWMutex
	lockGpuInstanceGetCreatableVgpus                     sync.RWMutex
	lockGpuInstanceGetInfo                               sync.RWMutex
	lockGpuInstanceGetVgpuHeterogeneousMode              sync.RWMutex
	lockGpuInstanceGetVgpuSchedulerLog                   sync.RWMutex
	lockGpuInstanceGetVgpuSchedulerState                 sync.RWMutex
	lockGpuInstanceGetVgpuTypeCreatablePlacements        sync.RWMutex
	lockGpuInstanceSetVgpuHeterogeneousMode              sync.RWMutex
	lockGpuInstanceSetVgpuSchedulerState                 sync.RWMutex
	lockInit                                             sync.RWMutex
	lockInitWithFlags                                    sync.RWMutex
	lockSetVgpuVersion                                   sync.RWMutex
	lockShutdown                                         sync.RWMutex
	lockSystemEventSetCreate                             sync.RWMutex
	lockSystemEventSetFree                               sync.RWMutex
	lockSystemEventSetWait                               sync.RWMutex
	lockSystemGetConfComputeCapabilities                 sync.RWMutex
	lockSystemGetConfComputeGpusReadyState               sync.RWMutex
	lockSystemGetConfComputeKeyRotationThresholdInfo     sync.RWMutex
	lockSystemGetConfComputeSettings                     sync.RWMutex
	lockSystemGetConfComputeState                        sync.RWMutex
	lockSystemGetCudaDriverVersion                       sync.RWMutex
	lockSystemGetCudaDriverVersion_v2                    sync.RWMutex
	lockSystemGetDriverBranch                            sync.RWMutex
	lockSystemGetDriverVersion                           sync.RWMutex
	lockSystemGetHicVersion                              sync.RWMutex
	lockSystemGetNVMLVersion                             sync.RWMutex
	lockSystemGetNvlinkBwMode                            sync.RWMutex
	lockSystemGetProcessName                             sync.RWMutex
	lockSystemGetTopologyGpuSet                          sync.RWMutex
	lockSystemRegisterEvents                             sync.RWMutex
	lockSystemSetConfComputeGpusReadyState               sync.RWMutex
	lockSystemSetConfComputeKeyRotationThresholdInfo     sync.RWMutex
	lockSystemSetNvlinkBwMode                            sync.RWMutex
	lockUnitGetCount                                     sync.RWMutex
	lockUnitGetDevices                                   sync.RWMutex
	lockUnitGetFanSpeedInfo                              sync.RWMutex
	lockUnitGetHandleByIndex                             sync.RWMutex
	lockUnitGetLedState                                  sync.RWMutex
	lockUnitGetPsuInfo                                   sync.RWMutex
	lockUnitGetTemperature                               sync.RWMutex
	lockUnitGetUnitInfo                                  sync.RWMutex
	lockUnitSetLedState                                  sync.RWMutex
	lockVgpuInstanceClearAccountingPids                  sync.RWMutex
	lockVgpuInstanceGetAccountingMode                    sync.RWMutex
	lockVgpuInstanceGetAccountingPids                    sync.RWMutex
	lockVgpuInstanceGetAccountingStats                   sync.RWMutex
	lockVgpuInstanceGetEccMode                           sync.RWMutex
	lockVgpuInstanceGetEncoderCapacity                   sync.RWMutex
	lockVgpuInstanceGetEncoderSessions                   sync.RWMutex
	lockVgpuInstanceGetEncoderStats                      sync.RWMutex
	lockVgpuInstanceGetFBCSessions                       sync.RWMutex
	lockVgpuInstanceGetFBCStats                          sync.RWMutex
	lockVgpuInstanceGetFbUsage                           sync.RWMutex
	lockVgpuInstanceGetFrameRateLimit                    sync.RWMutex
	lockVgpuInstanceGetGpuInstanceId                     sync.RWMutex
	lockVgpuInstanceGetGpuPciId                          sync.RWMutex
	lockVgpuInstanceGetLicenseInfo                       sync.RWMutex
	lockVgpuInstanceGetLicenseStatus                     sync.RWMutex
	lockVgpuInstanceGetMdevUUID                          sync.RWMutex
	lockVgpuInstanceGetMetadata                          sync.RWMutex
	lockVgpuInstanceGetRuntimeStateSize                  sync.RWMutex
	lockVgpuInstanceGetType                              sync.RWMutex
	lockVgpuInstanceGetUUID                              sync.RWMutex
	lockVgpuInstanceGetVmDriverVersion                   sync.RWMutex
	lockVgpuInstanceGetVmID                              sync.RWMutex
	lockVgpuInstanceSetEncoderCapacity                   sync.RWMutex
	lockVgpuTypeGetBAR1Info                              sync.RWMutex
	lockVgpuTypeGetCapabilities                          sync.RWMutex
	lockVgpuTypeGetClass                                 sync.RWMutex
	lockVgpuTypeGetDeviceID                              sync.RWMutex
	lockVgpuTypeGetFrameRateLimit                        sync.RWMutex
	lockVgpuTypeGetFramebufferSize                       sync.RWMutex
	lockVgpuTypeGetGpuInstanceProfileId                  sync.RWMutex
	lockVgpuTypeGetLicense                               sync.RWMutex
	lockVgpuTypeGetMaxInstances                          sync.RWMutex
	lockVgpuTypeGetMaxInstancesPerGpuInstance            sync.RWMutex
	lockVgpuTypeGetMaxInstancesPerVm                     sync.RWMutex
	lockVgpuTypeGetName                                  sync.RWMutex
	lockVgpuTypeGetNumDisplayHeads                       sync.RWMutex
	lockVgpuTypeGetResolution                            sync.RWMutex
}

// ComputeInstanceDestroy calls ComputeInstanceDestroyFunc.
func (mock *Interface) ComputeInstanceDestroy(computeInstance nvml.ComputeInstance) nvml.Return {
	if mock.ComputeInstanceDestroyFunc == nil {
		panic("Interface.ComputeInstanceDestroyFunc: method is nil but Interface.ComputeInstanceDestroy was just called")
	}
	callInfo := struct {
		ComputeInstance nvml.ComputeInstance
	}{
		ComputeInstance: computeInstance,
	}
	mock.lockComputeInstanceDestroy.Lock()
	mock.calls.ComputeInstanceDestroy = append(mock.calls.ComputeInstanceDestroy, callInfo)
	mock.lockComputeInstanceDestroy.Unlock()
	return mock.ComputeInstanceDestroyFunc(computeInstance)
}

// ComputeInstanceDestroyCalls gets all the calls that were made to ComputeInstanceDestroy.
// Check the length with:
//
//	len(mockedInterface.ComputeInstanceDestroyCalls())
func (mock *Interface) ComputeInstanceDestroyCalls() []struct {
	ComputeInstance nvml.ComputeInstance
} {
	var calls []struct {
		ComputeInstance nvml.ComputeInstance
	}
	mock.lockComputeInstanceDestroy.RLock()
	calls = mock.calls.ComputeInstanceDestroy
	mock.lockComputeInstanceDestroy.RUnlock()
	return calls
}

// ComputeInstanceGetInfo calls ComputeInstanceGetInfoFunc.
func (mock *Interface) ComputeInstanceGetInfo(computeInstance nvml.ComputeInstance) (nvml.ComputeInstanceInfo, nvml.Return) {
	if mock.ComputeInstanceGetInfoFunc == nil {
		panic("Interface.ComputeInstanceGetInfoFunc: method is nil but Interface.ComputeInstanceGetInfo was just called")
	}
	callInfo := struct {
		ComputeInstance nvml.ComputeInstance
	}{
		ComputeInstance: computeInstance,
	}
	mock.lockComputeInstanceGetInfo.Lock()
	mock.calls.ComputeInstanceGetInfo = append(mock.calls.ComputeInstanceGetInfo, callInfo)
	mock.lockComputeInstanceGetInfo.Unlock()
	return mock.ComputeInstanceGetInfoFunc(computeInstance)
}

// ComputeInstanceGetInfoCalls gets all the calls that were made to ComputeInstanceGetInfo.
// Check the length with:
//
//	len(mockedInterface.ComputeInstanceGetInfoCalls())
func (mock *Interface) ComputeInstanceGetInfoCalls() []struct {
	ComputeInstance nvml.ComputeInstance
} {
	var calls []struct {
		ComputeInstance nvml.ComputeInstance
	}
	mock.lockComputeInstanceGetInfo.RLock()
	calls = mock.calls.ComputeInstanceGetInfo
	mock.lockComputeInstanceGetInfo.RUnlock()
	return calls
}

// DeviceClearAccountingPids calls DeviceClearAccountingPidsFunc.
func (mock *Interface) DeviceClearAccountingPids(device nvml.Device) nvml.Return {
	if mock.DeviceClearAccountingPidsFunc == nil {
		panic("Interface.DeviceClearAccountingPidsFunc: method is nil but Interface.DeviceClearAccountingPids was just called")
	}
	callInfo := struct {
		Device nvml.Device
	}{
		Device: device,
	}
	mock.lockDeviceClearAccountingPids.Lock()
	mock.calls.DeviceClearAccountingPids = append(mock.calls.DeviceClearAccountingPids, callInfo)
	mock.lockDeviceClearAccountingPids.Unlock()
	return mock.DeviceClearAccountingPidsFunc(device)
}

// DeviceClearAccountingPidsCalls gets all the calls that were made to DeviceClearAccountingPids.
// Check the length with:
//
//	len(mockedInterface.DeviceClearAccountingPidsCalls())
func (mock *Interface) DeviceClearAccountingPidsCalls() []struct {
	Device nvml.Device
} {
	var calls []struct {
		Device nvml.Device
	}
	mock.lockDeviceClearAccountingPids.RLock()
	calls = mock.calls.DeviceClearAccountingPids
	mock.lockDeviceClearAccountingPids.RUnlock()
	return calls
}

// DeviceClearCpuAffinity calls DeviceClearCpuAffinityFunc.
func (mock *Interface) DeviceClearCpuAffinity(device nvml.Device) nvml.Return {
	if mock.DeviceClearCpuAffinityFunc == nil {
		panic("Interface.DeviceClearCpuAffinityFunc: method is nil but Interface.DeviceClearCpuAffinity was just called")
	}
	callInfo := struct {
		Device nvml.Device
	}{
		Device: device,
	}
	mock.lockDeviceClearCpuAffinity.Lock()
	mock.calls.DeviceClearCpuAffinity = append(mock.calls.DeviceClearCpuAffinity, callInfo)
	mock.lockDeviceClearCpuAffinity.Unlock()
	return mock.DeviceClearCpuAffinityFunc(device)
}

// DeviceClearCpuAffinityCalls gets all the calls that were made to DeviceClearCpuAffinity.
// Check the length with:
//
//	len(mockedInterface.DeviceClearCpuAffinityCalls())
func (mock *Interface) DeviceClearCpuAffinityCalls() []struct {
	Device nvml.Device
} {
	var calls []struct {
		Device nvml.Device
	}
	mock.lockDeviceClearCpuAffinity.RLock()
	calls = mock.calls.DeviceClearCpuAffinity
	mock.lockDeviceClearCpuAffinity.RUnlock()
	return calls
}

// DeviceClearEccErrorCounts calls DeviceClearEccErrorCountsFunc.
func (mock *Interface) DeviceClearEccErrorCounts(device nvml.Device, eccCounterType nvml.EccCounterType) nvml.Return {
	if mock.DeviceClearEccErrorCountsFunc == nil {
		panic("Interface.DeviceClearEccErrorCountsFunc: method is nil but Interface.DeviceClearEccErrorCounts was just called")
	}
	callInfo := struct {
		Device         nvml.Device
		EccCounterType nvml.EccCounterType
	}{
		Device:         device,
		EccCounterType: eccCounterType,
	}
	mock.lockDeviceClearEccErrorCounts.Lock()
	mock.calls.DeviceClearEccErrorCounts = append(mock.calls.DeviceClearEccErrorCounts, callInfo)
	mock.lockDeviceClearEccErrorCounts.Unlock()
	return mock.DeviceClearEccErrorCountsFunc(device, eccCounterType)
}

// DeviceClearEccErrorCountsCalls gets all the calls that were made to DeviceClearEccErrorCounts.
// Check the length with:
//
//	len(mockedInterface.DeviceClearEccErrorCountsCalls())
func (mock *Interface) DeviceClearEccErrorCountsCalls() []struct {
	Device         nvml.Device
	EccCounterType nvml.EccCounterType
} {
	var calls []struct {
		Device         nvml.Device
		EccCounterType nvml.EccCounterType
	}
	mock.lockDeviceClearEccErrorCounts.RLock()
	calls = mock.calls.DeviceClearEccErrorCounts
	mock.lockDeviceClearEccErrorCounts.RUnlock()
	return calls
}

// DeviceClearFieldValues calls DeviceClearFieldValuesFunc.
func (mock *Interface) DeviceClearFieldValues(device nvml.Device, fieldValues []nvml.FieldValue) nvml.Return {
	if mock.DeviceClearFieldValuesFunc == nil {
		panic("Interface.DeviceClearFieldValuesFunc: method is nil but Interface.DeviceClearFieldValues was just called")
	}
	callInfo := struct {
		Device      nvml.Device
		FieldValues []nvml.FieldValue
	}{
		Device:      device,
		FieldValues: fieldValues,
	}
	mock.lockDeviceClearFieldValues.Lock()
	mock.calls.DeviceClearFieldValues = append(mock.calls.DeviceClearFieldValues, callInfo)
	mock.lockDeviceClearFieldValues.Unlock()
	return mock.DeviceClearFieldValuesFunc(device, fieldValues)
}

// DeviceClearFieldValuesCalls gets all the calls that were made to DeviceClearFieldValues.
// Check the length with:
//
//	len(mockedInterface.DeviceClearFieldValuesCalls())
func (mock *Interface) DeviceClearFieldValuesCalls() []struct {
	Device      nvml.Device
	FieldValues []nvml.FieldValue
} {
	var calls []struct {
		Device      nvml.Device
		FieldValues []nvml.FieldValue
	}
	mock.lockDeviceClearFieldValues.RLock()
	calls = mock.calls.DeviceClearFieldValues
	mock.lockDeviceClearFieldValues.RUnlock()
	return calls
}

// DeviceCreateGpuInstance calls DeviceCreateGpuInstanceFunc.
func (mock *Interface) DeviceCreateGpuInstance(device nvml.Device, gpuInstanceProfileInfo *nvml.GpuInstanceProfileInfo) (nvml.GpuInstance, nvml.Return) {
	if mock.DeviceCreateGpuInstanceFunc == nil {
		panic("Interface.DeviceCreateGpuInstanceFunc: method is nil but Interface.DeviceCreateGpuInstance was just called")
	}
	callInfo := struct {
		Device                 nvml.Device
		GpuInstanceProfileInfo *nvml.GpuInstanceProfileInfo
	}{
		Device:                 device,
		GpuInstanceProfileInfo: gpuInstanceProfileInfo,
	}
	mock.lockDeviceCreateGpuInstance.Lock()
	mock.calls.DeviceCreateGpuInstance = append(mock.calls.DeviceCreateGpuInstance, callInfo)
	mock.lockDeviceCreateGpuInstance.Unlock()
	return mock.DeviceCreateGpuInstanceFunc(device, gpuInstanceProfileInfo)
}

// DeviceCreateGpuInstanceCalls gets all the calls that were made to DeviceCreateGpuInstance.
// Check the length with:
//
//	len(mockedInterface.DeviceCreateGpuInstanceCalls())
func (mock *Interface) DeviceCreateGpuInstanceCalls() []struct {
	Device                 nvml.Device
	GpuInstanceProfileInfo *nvml.GpuInstanceProfileInfo
} {
	var calls []struct {
		Device                 nvml.Device
		GpuInstanceProfileInfo *nvml.GpuInstanceProfileInfo
	}
	mock.lockDeviceCreateGpuInstance.RLock()
	calls = mock.calls.DeviceCreateGpuInstance
	mock.lockDeviceCreateGpuInstance.RUnlock()
	return calls
}

// DeviceCreateGpuInstanceWithPlacement calls DeviceCreateGpuInstanceWithPlacementFunc.
func (mock *Interface) DeviceCreateGpuInstanceWithPlacement(device nvml.Device, gpuInstanceProfileInfo *nvml.GpuInstanceProfileInfo, gpuInstancePlacement *nvml.GpuInstancePlacement) (nvml.GpuInstance, nvml.Return) {
	if mock.DeviceCreateGpuInstanceWithPlacementFunc == nil {
		panic("Interface.DeviceCreateGpuInstanceWithPlacementFunc: method is nil but Interface.DeviceCreateGpuInstanceWithPlacement was just called")
	}
	callInfo := struct {
		Device                 nvml.Device
		GpuInstanceProfileInfo *nvml.GpuInstanceProfileInfo
		GpuInstancePlacement   *nvml.GpuInstancePlacement
	}{
		Device:                 device,
		GpuInstanceProfileInfo: gpuInstanceProfileInfo,
		GpuInstancePlacement:   gpuInstancePlacement,
	}
	mock.lockDeviceCreateGpuInstanceWithPlacement.Lock()
	mock.calls.DeviceCreateGpuInstanceWithPlacement = append(mock.calls.DeviceCreateGpuInstanceWithPlacement, callInfo)
	mock.lockDeviceCreateGpuInstanceWithPlacement.Unlock()
	return mock.DeviceCreateGpuInstanceWithPlacementFunc(device, gpuInstanceProfileInfo, gpuInstancePlacement)
}

// DeviceCreateGpuInstanceWithPlacementCalls gets all the calls that were made to DeviceCreateGpuInstanceWithPlacement.
// Check the length with:
//
//	len(mockedInterface.DeviceCreateGpuInstanceWithPlacementCalls())
func (mock *Interface) DeviceCreateGpuInstanceWithPlacementCalls() []struct {
	Device                 nvml.Device
	GpuInstanceProfileInfo *nvml.GpuInstanceProfileInfo
	GpuInstancePlacement   *nvml.GpuInstancePlacement
} {
	var calls []struct {
		Device                 nvml.Device
		GpuInstanceProfileInfo *nvml.GpuInstanceProfileInfo
		GpuInstancePlacement   *nvml.GpuInstancePlacement
	}
	mock.lockDeviceCreateGpuInstanceWithPlacement.RLock()
	calls = mock.calls.DeviceCreateGpuInstanceWithPlacement
	mock.lockDeviceCreateGpuInstanceWithPlacement.RUnlock()
	return calls
}

// DeviceDiscoverGpus calls DeviceDiscoverGpusFunc.
func (mock *Interface) DeviceDiscoverGpus() (nvml.PciInfo, nvml.Return) {
	if mock.DeviceDiscoverGpusFunc == nil {
		panic("Interface.DeviceDiscoverGpusFunc: method is nil but Interface.DeviceDiscoverGpus was just called")
	}
	callInfo := struct {
	}{}
	mock.lockDeviceDiscoverGpus.Lock()
	mock.calls.DeviceDiscoverGpus = append(mock.calls.DeviceDiscoverGpus, callInfo)
	mock.lockDeviceDiscoverGpus.Unlock()
	return mock.DeviceDiscoverGpusFunc()
}

// DeviceDiscoverGpusCalls gets all the calls that were made to DeviceDiscoverGpus.
// Check the length with:
//
//	len(mockedInterface.DeviceDiscoverGpusCalls())
func (mock *Interface) DeviceDiscoverGpusCalls() []struct {
} {
	var calls []struct {
	}
	mock.lockDeviceDiscoverGpus.RLock()
	calls = mock.calls.DeviceDiscoverGpus
	mock.lockDeviceDiscoverGpus.RUnlock()
	return calls
}

// DeviceFreezeNvLinkUtilizationCounter calls DeviceFreezeNvLinkUtilizationCounterFunc.
func (mock *Interface) DeviceFreezeNvLinkUtilizationCounter(device nvml.Device, n1 int, n2 int, enableState nvml.EnableState) nvml.Return {
	if mock.DeviceFreezeNvLinkUtilizationCounterFunc == nil {
		panic("Interface.DeviceFreezeNvLinkUtilizationCounterFunc: method is nil but Interface.DeviceFreezeNvLinkUtilizationCounter was just called")
	}
	callInfo := struct {
		Device      nvml.Device
		N1          int
		N2          int
		EnableState nvml.EnableState
	}{
		Device:      device,
		N1:          n1,
		N2:          n2,
		EnableState: enableState,
	}
	mock.lockDeviceFreezeNvLinkUtilizationCounter.Lock()
	mock.calls.DeviceFreezeNvLinkUtilizationCounter = append(mock.calls.DeviceFreezeNvLinkUtilizationCounter, callInfo)
	mock.lockDeviceFreezeNvLinkUtilizationCounter.Unlock()
	return mock.DeviceFreezeNvLinkUtilizationCounterFunc(device, n1, n2, enableState)
}

// DeviceFreezeNvLinkUtilizationCounterCalls gets all the calls that were made to DeviceFreezeNvLinkUtilizationCounter.
// Check the length with:
//
//	len(mockedInterface.DeviceFreezeNvLinkUtilizationCounterCalls())
func (mock *Interface) DeviceFreezeNvLinkUtilizationCounterCalls() []struct {
	Device      nvml.Device
	N1          int
	N2          int
	EnableState nvml.EnableState
} {
	var calls []struct {
		Device      nvml.Device
		N1          int
		N2          int
		EnableState nvml.EnableState
	}
	mock.lockDeviceFreezeNvLinkUtilizationCounter.RLock()
	calls = mock.calls.DeviceFreezeNvLinkUtilizationCounter
	mock.lockDeviceFreezeNvLinkUtilizationCounter.RUnlock()
	return calls
}

// DeviceGetAPIRestriction calls DeviceGetAPIRestrictionFunc.
func (mock *Interface) DeviceGetAPIRestriction(device nvml.Device, restrictedAPI nvml.RestrictedAPI) (nvml.EnableState, nvml.Return) {
	if mock.DeviceGetAPIRestrictionFunc == nil {
		panic("Interface.DeviceGetAPIRestrictionFunc: method is nil but Interface.DeviceGetAPIRestriction was just called")
	}
	callInfo := struct {
		Device        nvml.Device
		RestrictedAPI nvml.RestrictedAPI
	}{
		Device:        device,
		RestrictedAPI: restrictedAPI,
	}
	mock.lockDeviceGetAPIRestriction.Lock()
	mock.calls.DeviceGetAPIRestriction = append(mock.calls.DeviceGetAPIRestriction, callInfo)
	mock.lockDeviceGetAPIRestriction.Unlock()
	return mock.DeviceGetAPIRestrictionFunc(device, restrictedAPI)
}

// DeviceGetAPIRestrictionCalls gets all the calls that were made to DeviceGetAPIRestriction.
// Check the length with:
//
//	len(mockedInterface.DeviceGetAPIRestrictionCalls())
func (mock *Interface) DeviceGetAPIRestrictionCalls() []struct {
	Device        nvml.Device
	RestrictedAPI nvml.RestrictedAPI
} {
	var calls []struct {
		Device        nvml.Device
		RestrictedAPI nvml.RestrictedAPI
	}
	mock.lockDeviceGetAPIRestriction.RLock()
	calls = mock.calls.DeviceGetAPIRestriction
	mock.lockDeviceGetAPIRestriction.RUnlock()
	return calls
}

// DeviceGetAccountingBufferSize calls DeviceGetAccountingBufferSizeFunc.
func (mock *Interface) DeviceGetAccountingBufferSize(device nvml.Device) (int, nvml.Return) {
	if mock.DeviceGetAccountingBufferSizeFunc == nil {
		panic("Interface.DeviceGetAccountingBufferSizeFunc: method is nil but Interface.DeviceGetAccountingBufferSize was just called")
	}
	callInfo := struct {
		Device nvml.Device
	}{
		Device: device,
	}
	mock.lockDeviceGetAccountingBufferSize.Lock()
	mock.calls.DeviceGetAccountingBufferSize = append(mock.calls.DeviceGetAccountingBufferSize, callInfo)
	mock.lockDeviceGetAccountingBufferSize.Unlock()
	return mock.DeviceGetAccountingBufferSizeFunc(device)
}

// DeviceGetAccountingBufferSizeCalls gets all the calls that were made to DeviceGetAccountingBufferSize.
// Check the length with:
//
//	len(mockedInterface.DeviceGetAccountingBufferSizeCalls())
func (mock *Interface) DeviceGetAccountingBufferSizeCalls() []struct {
	Device nvml.Device
} {
	var calls []struct {
		Device nvml.Device
	}
	mock.lockDeviceGetAccountingBufferSize.RLock()
	calls = mock.calls.DeviceGetAccountingBufferSize
	mock.lockDeviceGetAccountingBufferSize.RUnlock()
	return calls
}

// DeviceGetAccountingMode calls DeviceGetAccountingModeFunc.
func (mock *Interface) DeviceGetAccountingMode(device nvml.Device) (nvml.EnableState, nvml.Return) {
	if mock.DeviceGetAccountingModeFunc == nil {
		panic("Interface.DeviceGetAccountingModeFunc: method is nil but Interface.DeviceGetAccountingMode was just called")
	}
	callInfo := struct {
		Device nvml.Device
	}{
		Device: device,
	}
	mock.lockDeviceGetAccountingMode.Lock()
	mock.calls.DeviceGetAccountingMode = append(mock.calls.DeviceGetAccountingMode, callInfo)
	mock.lockDeviceGetAccountingMode.Unlock()
	return mock.DeviceGetAccountingModeFunc(device)
}

// DeviceGetAccountingModeCalls gets all the calls that were made to DeviceGetAccountingMode.
// Check the length with:
//
//	len(mockedInterface.DeviceGetAccountingModeCalls())
func (mock *Interface) DeviceGetAccountingModeCalls() []struct {
	Device nvml.Device
} {
	var calls []struct {
		Device nvml.Device
	}
	mock.lockDeviceGetAccountingMode.RLock()
	calls = mock.calls.DeviceGetAccountingMode
	mock.lockDeviceGetAccountingMode.RUnlock()
	return calls
}

// DeviceGetAccountingPids calls DeviceGetAccountingPidsFunc.
func (mock *Interface) DeviceGetAccountingPids(device nvml.Device) ([]int, nvml.Return) {
	if mock.DeviceGetAccountingPidsFunc == nil {
		panic("Interface.DeviceGetAccountingPidsFunc: method is nil but Interface.DeviceGetAccountingPids was just called")
	}
	callInfo := struct {
		Device nvml.Device
	}{
		Device: device,
	}
	mock.lockDeviceGetAccountingPids.Lock()
	mock.calls.DeviceGetAccountingPids = append(mock.calls.DeviceGetAccountingPids, callInfo)
	mock.lockDeviceGetAccountingPids.Unlock()
	return mock.DeviceGetAccountingPidsFunc(device)
}

// DeviceGetAccountingPidsCalls gets all the calls that were made to DeviceGetAccountingPids.
// Check the length with:
//
//	len(mockedInterface.DeviceGetAccountingPidsCalls())
func (mock *Interface) DeviceGetAccountingPidsCalls() []struct {
	Device nvml.Device
} {
	var calls []struct {
		Device nvml.Device
	}
	mock.lockDeviceGetAccountingPids.RLock()
	calls = mock.calls.DeviceGetAccountingPids
	mock.lockDeviceGetAccountingPids.RUnlock()
	return calls
}

// DeviceGetAccountingStats calls DeviceGetAccountingStatsFunc.
func (mock *Interface) DeviceGetAccountingStats(device nvml.Device, v uint32) (nvml.AccountingStats, nvml.Return) {
	if mock.DeviceGetAccountingStatsFunc == nil {
		panic("Interface.DeviceGetAccountingStatsFunc: method is nil but Interface.DeviceGetAccountingStats was just called")
	}
	callInfo := struct {
		Device nvml.Device
		V      uint32
	}{
		Device: device,
		V:      v,
	}
	mock.lockDeviceGetAccountingStats.Lock()
	mock.calls.DeviceGetAccountingStats = append(mock.calls.DeviceGetAccountingStats, callInfo)
	mock.lockDeviceGetAccountingStats.Unlock()
	return mock.DeviceGetAccountingStatsFunc(device, v)
}

// DeviceGetAccountingStatsCalls gets all the calls that were made to DeviceGetAccountingStats.
// Check the length with:
//
//	len(mockedInterface.DeviceGetAccountingStatsCalls())
func (mock *Interface) DeviceGetAccountingStatsCalls() []struct {
	Device nvml.Device
	V      uint32
} {
	var calls []struct {
		Device nvml.Device
		V      uint32
	}
	mock.lockDeviceGetAccountingStats.RLock()
	calls = mock.calls.DeviceGetAccountingStats
	mock.lockDeviceGetAccountingStats.RUnlock()
	return calls
}

// DeviceGetActiveVgpus calls DeviceGetActiveVgpusFunc.
func (mock *Interface) DeviceGetActiveVgpus(device nvml.Device) ([]nvml.VgpuInstance, nvml.Return) {
	if mock.DeviceGetActiveVgpusFunc == nil {
		panic("Interface.DeviceGetActiveVgpusFunc: method is nil but Interface.DeviceGetActiveVgpus was just called")
	}
	callInfo := struct {
		Device nvml.Device
	}{
		Device: device,
	}
	mock.lockDeviceGetActiveVgpus.Lock()
	mock.calls.DeviceGetActiveVgpus = append(mock.calls.DeviceGetActiveVgpus, callInfo)
	mock.lockDeviceGetActiveVgpus.Unlock()
	return mock.DeviceGetActiveVgpusFunc(device)
}

// DeviceGetActiveVgpusCalls gets all the calls that were made to DeviceGetActiveVgpus.
// Check the length with:
//
//	len(mockedInterface.DeviceGetActiveVgpusCalls())
func (mock *Interface) DeviceGetActiveVgpusCalls() []struct {
	Device nvml.Device
} {
	var calls []struct {
		Device nvml.Device
	}
	mock.lockDeviceGetActiveVgpus.RLock()
	calls = mock.calls.DeviceGetActiveVgpus
	mock.lockDeviceGetActiveVgpus.RUnlock()
	return calls
}

// DeviceGetAdaptiveClockInfoStatus calls DeviceGetAdaptiveClockInfoStatusFunc.
func (mock *Interface) DeviceGetAdaptiveClockInfoStatus(device nvml.Device) (uint32, nvml.Return) {
	if mock.DeviceGetAdaptiveClockInfoStatusFunc == nil {
		panic("Interface.DeviceGetAdaptiveClockInfoStatusFunc: method is nil but Interface.DeviceGetAdaptiveClockInfoStatus was just called")
	}
	callInfo := struct {
		Device nvml.Device
	}{
		Device: device,
	}
	mock.lockDeviceGetAdaptiveClockInfoStatus.Lock()
	mock.calls.DeviceGetAdaptiveClockInfoStatus = append(mock.calls.DeviceGetAdaptiveClockInfoStatus, callInfo)
	mock.lockDeviceGetAdaptiveClockInfoStatus.Unlock()
	return mock.DeviceGetAdaptiveClockInfoStatusFunc(device)
}

// DeviceGetAdaptiveClockInfoStatusCalls gets all the calls that were made to DeviceGetAdaptiveClockInfoStatus.
// Check the length with:
//
//	len(mockedInterface.DeviceGetAdaptiveClockInfoStatusCalls())
func (mock *Interface) DeviceGetAdaptiveClockInfoStatusCalls() []struct {
	Device nvml.Device
} {
	var calls []struct {
		Device nvml.Device
	}
	mock.lockDeviceGetAdaptiveClockInfoStatus.RLock()
	calls = mock.calls.DeviceGetAdaptiveClockInfoStatus
	mock.lockDeviceGetAdaptiveClockInfoStatus.RUnlock()
	return calls
}

// DeviceGetAddressingMode calls DeviceGetAddressingModeFunc.
func (mock *Interface) DeviceGetAddressingMode(device nvml.Device) (nvml.DeviceAddressingMode, nvml.Return) {
	if mock.DeviceGetAddressingModeFunc == nil {
		panic("Interface.DeviceGetAddressingModeFunc: method is nil but Interface.DeviceGetAddressingMode was just called")
	}
	callInfo := struct {
		Device nvml.Device
	}{
		Device: device,
	}
	mock.lockDeviceGetAddressingMode.Lock()
	mock.calls.DeviceGetAddressingMode = append(mock.calls.DeviceGetAddressingMode, callInfo)
	mock.lockDeviceGetAddressingMode.Unlock()
	return mock.DeviceGetAddressingModeFunc(device)
}

// DeviceGetAddressingModeCalls gets all the calls that were made to DeviceGetAddressingMode.
// Check the length with:
//
//	len(mockedInterface.DeviceGetAddressingModeCalls())
func (mock *Interface) DeviceGetAddressingModeCalls() []struct {
	Device nvml.Device
} {
	var calls []struct {
		Device nvml.Device
	}
	mock.lockDeviceGetAddressingMode.RLock()
	calls = mock.calls.DeviceGetAddressingMode
	mock.lockDeviceGetAddressingMode.RUnlock()
	return calls
}

// DeviceGetApplicationsClock calls DeviceGetApplicationsClockFunc.
func (mock *Interface) DeviceGetApplicationsClock(device nvml.Device, clockType nvml.ClockType) (uint32, nvml.Return) {
	if mock.DeviceGetApplicationsClockFunc == nil {
		panic("Interface.DeviceGetApplicationsClockFunc: method is nil but Interface.DeviceGetApplicationsClock was just called")
	}
	callInfo := struct {
		Device    nvml.Device
		ClockType nvml.ClockType
	}{
		Device:    device,
		ClockType: clockType,
	}
	mock.lockDeviceGetApplicationsClock.Lock()
	mock.calls.DeviceGetApplicationsClock = append(mock.calls.DeviceGetApplicationsClock, callInfo)
	mock.lockDeviceGetApplicationsClock.Unlock()
	return mock.DeviceGetApplicationsClockFunc(device, clockType)
}

// DeviceGetApplicationsClockCalls gets all the calls that were made to DeviceGetApplicationsClock.
// Check the length with:
//
//	len(mockedInterface.DeviceGetApplicationsClockCalls())
func (mock *Interface) DeviceGetApplicationsClockCalls() []struct {
	Device    nvml.Device
	ClockType nvml.ClockType
} {
	var calls []struct {
		Device    nvml.Device
		ClockType nvml.ClockType
	}
	mock.lockDeviceGetApplicationsClock.RLock()
	calls = mock.calls.DeviceGetApplicationsClock
	mock.lockDeviceGetApplicationsClock.RUnlock()
	return calls
}

// DeviceGetArchitecture calls DeviceGetArchitectureFunc.
func (mock *Interface) DeviceGetArchitecture(device nvml.Device) (nvml.DeviceArchitecture, nvml.Return) {
	if mock.DeviceGetArchitectureFunc == nil {
		panic("Interface.DeviceGetArchitectureFunc: method is nil but Interface.DeviceGetArchitecture was just called")
	}
	callInfo := struct {
		Device nvml.Device
	}{
		Device: device,
	}
	mock.lockDeviceGetArchitecture.Lock()
	mock.calls.DeviceGetArchitecture = append(mock.calls.DeviceGetArchitecture, callInfo)
	mock.lockDeviceGetArchitecture.Unlock()
	return mock.DeviceGetArchitectureFunc(device)
}

// DeviceGetArchitectureCalls gets all the calls that were made to DeviceGetArchitecture.
// Check the length with:
//
//	len(mockedInterface.DeviceGetArchitectureCalls())
func (mock *Interface) DeviceGetArchitectureCalls() []struct {
	Device nvml.Device
} {
	var calls []struct {
		Device nvml.Device
	}
	mock.lockDeviceGetArchitecture.RLock()
	calls = mock.calls.DeviceGetArchitecture
	mock.lockDeviceGetArchitecture.RUnlock()
	return calls
}

// DeviceGetAttributes calls DeviceGetAttributesFunc.
func (mock *Interface) DeviceGetAttributes(device nvml.Device) (nvml.DeviceAttributes, nvml.Return) {
	if mock.DeviceGetAttributesFunc == nil {
		panic("Interface.DeviceGetAttributesFunc: method is nil but Interface.DeviceGetAttributes was just called")
	}
	callInfo := struct {
		Device nvml.Device
	}{
		Device: device,
	}
	mock.lockDeviceGetAttributes.Lock()
	mock.calls.DeviceGetAttributes = append(mock.calls.DeviceGetAttributes, callInfo)
	mock.lockDeviceGetAttributes.Unlock()
	return mock.DeviceGetAttributesFunc(device)
}

// DeviceGetAttributesCalls gets all the calls that were made to DeviceGetAttributes.
// Check the length with:
//
//	len(mockedInterface.DeviceGetAttributesCalls())
func (mock *Interface) DeviceGetAttributesCalls() []struct {
	Device nvml.Device
} {
	var calls []struct {
		Device nvml.Device
	}
	mock.lockDeviceGetAttributes.RLock()
	calls = mock.calls.DeviceGetAttributes
	mock.lockDeviceGetAttributes.RUnlock()
	return calls
}

// DeviceGetAutoBoostedClocksEnabled calls DeviceGetAutoBoostedClocksEnabledFunc.
func (mock *Interface) DeviceGetAutoBoostedClocksEnabled(device nvml.Device) (nvml.EnableState, nvml.EnableState, nvml.Return) {
	if mock.DeviceGetAutoBoostedClocksEnabledFunc == nil {
		panic("Interface.DeviceGetAutoBoostedClocksEnabledFunc: method is nil but Interface.DeviceGetAutoBoostedClocksEnabled was just called")
	}
	callInfo := struct {
		Device nvml.Device
	}{
		Device: device,
	}
	mock.lockDeviceGetAutoBoostedClocksEnabled.Lock()
	mock.calls.DeviceGetAutoBoostedClocksEnabled = append(mock.calls.DeviceGetAutoBoostedClocksEnabled, callInfo)
	mock.lockDeviceGetAutoBoostedClocksEnabled.Unlock()
	return mock.DeviceGetAutoBoostedClocksEnabledFunc(device)
}

// DeviceGetAutoBoostedClocksEnabledCalls gets all the calls that were made to DeviceGetAutoBoostedClocksEnabled.
// Check the length with:
//
//	len(mockedInterface.DeviceGetAutoBoostedClocksEnabledCalls())
func (mock *Interface) DeviceGetAutoBoostedClocksEnabledCalls() []struct {
	Device nvml.Device
} {
	var calls []struct {
		Device nvml.Device
	}
	mock.lockDeviceGetAutoBoostedClocksEnabled.RLock()
	calls = mock.calls.DeviceGetAutoBoostedClocksEnabled
	mock.lockDeviceGetAutoBoostedClocksEnabled.RUnlock()
	return calls
}

// DeviceGetBAR1MemoryInfo calls DeviceGetBAR1MemoryInfoFunc.
func (mock *Interface) DeviceGetBAR1MemoryInfo(device nvml.Device) (nvml.BAR1Memory, nvml.Return) {
	if mock.DeviceGetBAR1MemoryInfoFunc == nil {
		panic("Interface.DeviceGetBAR1MemoryInfoFunc: method is nil but Interface.DeviceGetBAR1MemoryInfo was just called")
	}
	callInfo := struct {
		Device nvml.Device
	}{
		Device: device,
	}
	mock.lockDeviceGetBAR1MemoryInfo.Lock()
	mock.calls.DeviceGetBAR1MemoryInfo = append(mock.calls.DeviceGetBAR1MemoryInfo, callInfo)
	mock.lockDeviceGetBAR1MemoryInfo.Unlock()
	return mock.DeviceGetBAR1MemoryInfoFunc(device)
}

// DeviceGetBAR1MemoryInfoCalls gets all the calls that were made to DeviceGetBAR1MemoryInfo.
// Check the length with:
//
//	len(mockedInterface.DeviceGetBAR1MemoryInfoCalls())
func (mock *Interface) DeviceGetBAR1MemoryInfoCalls() []struct {
	Device nvml.Device
} {
	var calls []struct {
		Device nvml.Device
	}
	mock.lockDeviceGetBAR1MemoryInfo.RLock()
	calls = mock.calls.DeviceGetBAR1MemoryInfo
	mock.lockDeviceGetBAR1MemoryInfo.RUnlock()
	return calls
}

// DeviceGetBoardId calls DeviceGetBoardIdFunc.
func (mock *Interface) DeviceGetBoardId(device nvml.Device) (uint32, nvml.Return) {
	if mock.DeviceGetBoardIdFunc == nil {
		panic("Interface.DeviceGetBoardIdFunc: method is nil but Interface.DeviceGetBoardId was just called")
	}
	callInfo := struct {
		Device nvml.Device
	}{
		Device: device,
	}
	mock.lockDeviceGetBoardId.Lock()
	mock.calls.DeviceGetBoardId = append(mock.calls.DeviceGetBoardId, callInfo)
	mock.lockDeviceGetBoardId.Unlock()
	return mock.DeviceGetBoardIdFunc(device)
}

// DeviceGetBoardIdCalls gets all the calls that were made to DeviceGetBoardId.
// Check the length with:
//
//	len(mockedInterface.DeviceGetBoardIdCalls())
func (mock *Interface) DeviceGetBoardIdCalls() []struct {
	Device nvml.Device
} {
	var calls []struct {
		Device nvml.Device
	}
	mock.lockDeviceGetBoardId.RLock()
	calls = mock.calls.DeviceGetBoardId
	mock.lockDeviceGetBoardId.RUnlock()
	return calls
}

// DeviceGetBoardPartNumber calls DeviceGetBoardPartNumberFunc.
func (mock *Interface) DeviceGetBoardPartNumber(device nvml.Device) (string, nvml.Return) {
	if mock.DeviceGetBoardPartNumberFunc == nil {
		panic("Interface.DeviceGetBoardPartNumberFunc: method is nil but Interface.DeviceGetBoardPartNumber was just called")
	}
	callInfo := struct {
		Device nvml.Device
	}{
		Device: device,
	}
	mock.lockDeviceGetBoardPartNumber.Lock()
	mock.calls.DeviceGetBoardPartNumber = append(mock.calls.DeviceGetBoardPartNumber, callInfo)
	mock.lockDeviceGetBoardPartNumber.Unlock()
	return mock.DeviceGetBoardPartNumberFunc(device)
}

// DeviceGetBoardPartNumberCalls gets all the calls that were made to DeviceGetBoardPartNumber.
// Check the length with:
//
//	len(mockedInterface.DeviceGetBoardPartNumberCalls())
func (mock *Interface) DeviceGetBoardPartNumberCalls() []struct {
	Device nvml.Device
} {
	var calls []struct {
		Device nvml.Device
	}
	mock.lockDeviceGetBoardPartNumber.RLock()
	calls = mock.calls.DeviceGetBoardPartNumber
	mock.lockDeviceGetBoardPartNumber.RUnlock()
	return calls
}

// DeviceGetBrand calls DeviceGetBrandFunc.
func (mock *Interface) DeviceGetBrand(device nvml.Device) (nvml.BrandType, nvml.Return) {
	if mock.DeviceGetBrandFunc == nil {
		panic("Interface.DeviceGetBrandFunc: method is nil but Interface.DeviceGetBrand was just called")
	}
	callInfo := struct {
		Device nvml.Device
	}{
		Device: device,
	}
	mock.lockDeviceGetBrand.Lock()
	mock.calls.DeviceGetBrand = append(mock.calls.DeviceGetBrand, callInfo)
	mock.lockDeviceGetBrand.Unlock()
	return mock.DeviceGetBrandFunc(device)
}

// DeviceGetBrandCalls gets all the calls that were made to DeviceGetBrand.
// Check the length with:
//
//	len(mockedInterface.DeviceGetBrandCalls())
func (mock *Interface) DeviceGetBrandCalls() []struct {
	Device nvml.Device
} {
	var calls []struct {
		Device nvml.Device
	}
	mock.lockDeviceGetBrand.RLock()
	calls = mock.calls.DeviceGetBrand
	mock.lockDeviceGetBrand.RUnlock()
	return calls
}

// DeviceGetBridgeChipInfo calls DeviceGetBridgeChipInfoFunc.
func (mock *Interface) DeviceGetBridgeChipInfo(device nvml.Device) (nvml.BridgeChipHierarchy, nvml.Return) {
	if mock.DeviceGetBridgeChipInfoFunc == nil {
		panic("Interface.DeviceGetBridgeChipInfoFunc: method is nil but Interface.DeviceGetBridgeChipInfo was just called")
	}
	callInfo := struct {
		Device nvml.Device
	}{
		Device: device,
	}
	mock.lockDeviceGetBridgeChipInfo.Lock()
	mock.calls.DeviceGetBridgeChipInfo = append(mock.calls.DeviceGetBridgeChipInfo, callInfo)
	mock.lockDeviceGetBridgeChipInfo.Unlock()
	return mock.DeviceGetBridgeChipInfoFunc(device)
}

// DeviceGetBridgeChipInfoCalls gets all the calls that were made to DeviceGetBridgeChipInfo.
// Check the length with:
//
//	len(mockedInterface.DeviceGetBridgeChipInfoCalls())
func (mock *Interface) DeviceGetBridgeChipInfoCalls() []struct {
	Device nvml.Device
} {
	var calls []struct {
		Device nvml.Device
	}
	mock.lockDeviceGetBridgeChipInfo.RLock()
	calls = mock.calls.DeviceGetBridgeChipInfo
	mock.lockDeviceGetBridgeChipInfo.RUnlock()
	return calls
}

// DeviceGetBusType calls DeviceGetBusTypeFunc.
func (mock *Interface) DeviceGetBusType(device nvml.Device) (nvml.BusType, nvml.Return) {
	if mock.DeviceGetBusTypeFunc == nil {
		panic("Interface.DeviceGetBusTypeFunc: method is nil but Interface.DeviceGetBusType was just called")
	}
	callInfo := struct {
		Device nvml.Device
	}{
		Device: device,
	}
	mock.lockDeviceGetBusType.Lock()
	mock.calls.DeviceGetBusType = append(mock.calls.DeviceGetBusType, callInfo)
	mock.lockDeviceGetBusType.Unlock()
	return mock.DeviceGetBusTypeFunc(device)
}

// DeviceGetBusTypeCalls gets all the calls that were made to DeviceGetBusType.
// Check the length with:
//
//	len(mockedInterface.DeviceGetBusTypeCalls())
func (mock *Interface) DeviceGetBusTypeCalls() []struct {
	Device nvml.Device
} {
	var calls []struct {
		Device nvml.Device
	}
	mock.lockDeviceGetBusType.RLock()
	calls = mock.calls.DeviceGetBusType
	mock.lockDeviceGetBusType.RUnlock()
	return calls
}

// DeviceGetC2cModeInfoV calls DeviceGetC2cModeInfoVFunc.
func (mock *Interface) DeviceGetC2cModeInfoV(device nvml.Device) nvml.C2cModeInfoHandler {
	if mock.DeviceGetC2cModeInfoVFunc == nil {
		panic("Interface.DeviceGetC2cModeInfoVFunc: method is nil but Interface.DeviceGetC2cModeInfoV was just called")
	}
	callInfo := struct {
		Device nvml.Device
	}{
		Device: device,
	}
	mock.lockDeviceGetC2cModeInfoV.Lock()
	mock.calls.DeviceGetC2cModeInfoV = append(mock.calls.DeviceGetC2cModeInfoV, callInfo)
	mock.lockDeviceGetC2cModeInfoV.Unlock()
	return mock.DeviceGetC2cModeInfoVFunc(device)
}

// DeviceGetC2cModeInfoVCalls gets all the calls that were made to DeviceGetC2cModeInfoV.
// Check the length with:
//
//	len(mockedInterface.DeviceGetC2cModeInfoVCalls())
func (mock *Interface) DeviceGetC2cModeInfoVCalls() []struct {
	Device nvml.Device
} {
	var calls []struct {
		Device nvml.Device
	}
	mock.lockDeviceGetC2cModeInfoV.RLock()
	calls = mock.calls.DeviceGetC2cModeInfoV
	mock.lockDeviceGetC2cModeInfoV.RUnlock()
	return calls
}

// DeviceGetCapabilities calls DeviceGetCapabilitiesFunc.
func (mock *Interface) DeviceGetCapabilities(device nvml.Device) (nvml.DeviceCapabilities, nvml.Return) {
	if mock.DeviceGetCapabilitiesFunc == nil {
		panic("Interface.DeviceGetCapabilitiesFunc: method is nil but Interface.DeviceGetCapabilities was just called")
	}
	callInfo := struct {
		Device nvml.Device
	}{
		Device: device,
	}
	mock.lockDeviceGetCapabilities.Lock()
	mock.calls.DeviceGetCapabilities = append(mock.calls.DeviceGetCapabilities, callInfo)
	mock.lockDeviceGetCapabilities.Unlock()
	return mock.DeviceGetCapabilitiesFunc(device)
}

// DeviceGetCapabilitiesCalls gets all the calls that were made to DeviceGetCapabilities.
// Check the length with:
//
//	len(mockedInterface.DeviceGetCapabilitiesCalls())
func (mock *Interface) DeviceGetCapabilitiesCalls() []struct {
	Device nvml.Device
} {
	var calls []struct {
		Device nvml.Device
	}
	mock.lockDeviceGetCapabilities.RLock()
	calls = mock.calls.DeviceGetCapabilities
	mock.lockDeviceGetCapabilities.RUnlock()
	return calls
}

// DeviceGetClkMonStatus calls DeviceGetClkMonStatusFunc.
func (mock *Interface) DeviceGetClkMonStatus(device nvml.Device) (nvml.ClkMonStatus, nvml.Return) {
	if mock.DeviceGetClkMonStatusFunc == nil {
		panic("Interface.DeviceGetClkMonStatusFunc: method is nil but Interface.DeviceGetClkMonStatus was just called")
	}
	callInfo := struct {
		Device nvml.Device
	}{
		Device: device,
	}
	mock.lockDeviceGetClkMonStatus.Lock()
	mock.calls.DeviceGetClkMonStatus = append(mock.calls.DeviceGetClkMonStatus, callInfo)
	mock.lockDeviceGetClkMonStatus.Unlock()
	return mock.DeviceGetClkMonStatusFunc(device)
}

// DeviceGetClkMonStatusCalls gets all the calls that were made to DeviceGetClkMonStatus.
// Check the length with:
//
//	len(mockedInterface.DeviceGetClkMonStatusCalls())
func (mock *Interface) DeviceGetClkMonStatusCalls() []struct {
	Device nvml.Device
} {
	var calls []struct {
		Device nvml.Device
	}
	mock.lockDeviceGetClkMonStatus.RLock()
	calls = mock.calls.DeviceGetClkMonStatus
	mock.lockDeviceGetClkMonStatus.RUnlock()
	return calls
}

// DeviceGetClock calls DeviceGetClockFunc.
func (mock *Interface) DeviceGetClock(device nvml.Device, clockType nvml.ClockType, clockId nvml.ClockId) (uint32, nvml.Return) {
	if mock.DeviceGetClockFunc == nil {
		panic("Interface.DeviceGetClockFunc: method is nil but Interface.DeviceGetClock was just called")
	}
	callInfo := struct {
		Device    nvml.Device
		ClockType nvml.ClockType
		ClockId   nvml.ClockId
	}{
		Device:    device,
		ClockType: clockType,
		ClockId:   clockId,
	}
	mock.lockDeviceGetClock.Lock()
	mock.calls.DeviceGetClock = append(mock.calls.DeviceGetClock, callInfo)
	mock.lockDeviceGetClock.Unlock()
	return mock.DeviceGetClockFunc(device, clockType, clockId)
}

// DeviceGetClockCalls gets all the calls that were made to DeviceGetClock.
// Check the length with:
//
//	len(mockedInterface.DeviceGetClockCalls())
func (mock *Interface) DeviceGetClockCalls() []struct {
	Device    nvml.Device
	ClockType nvml.ClockType
	ClockId   nvml.ClockId
} {
	var calls []struct {
		Device    nvml.Device
		ClockType nvml.ClockType
		ClockId   nvml.ClockId
	}
	mock.lockDeviceGetClock.RLock()
	calls = mock.calls.DeviceGetClock
	mock.lockDeviceGetClock.RUnlock()
	return calls
}

// DeviceGetClockInfo calls DeviceGetClockInfoFunc.
func (mock *Interface) DeviceGetClockInfo(device nvml.Device, clockType nvml.ClockType) (uint32, nvml.Return) {
	if mock.DeviceGetClockInfoFunc == nil {
		panic("Interface.DeviceGetClockInfoFunc: method is nil but Interface.DeviceGetClockInfo was just called")
	}
	callInfo := struct {
		Device    nvml.Device
		ClockType nvml.ClockType
	}{
		Device:    device,
		ClockType: clockType,
	}
	mock.lockDeviceGetClockInfo.Lock()
	mock.calls.DeviceGetClockInfo = append(mock.calls.DeviceGetClockInfo, callInfo)
	mock.lockDeviceGetClockInfo.Unlock()
	return mock.DeviceGetClockInfoFunc(device, clockType)
}

// DeviceGetClockInfoCalls gets all the calls that were made to DeviceGetClockInfo.
// Check the length with:
//
//	len(mockedInterface.DeviceGetClockInfoCalls())
func (mock *Interface) DeviceGetClockInfoCalls() []struct {
	Device    nvml.Device
	ClockType nvml.ClockType
} {
	var calls []struct {
		Device    nvml.Device
		ClockType nvml.ClockType
	}
	mock.lockDeviceGetClockInfo.RLock()
	calls = mock.calls.DeviceGetClockInfo
	mock.lockDeviceGetClockInfo.RUnlock()
	return calls
}

// DeviceGetClockOffsets calls DeviceGetClockOffsetsFunc.
func (mock *Interface) DeviceGetClockOffsets(device nvml.Device) (nvml.ClockOffset, nvml.Return) {
	if mock.DeviceGetClockOffsetsFunc == nil {
		panic("Interface.DeviceGetClockOffsetsFunc: method is nil but Interface.DeviceGetClockOffsets was just called")
	}
	callInfo := struct {
		Device nvml.Device
	}{
		Device: device,
	}
	mock.lockDeviceGetClockOffsets.Lock()
	mock.calls.DeviceGetClockOffsets = append(mock.calls.DeviceGetClockOffsets, callInfo)
	mock.lockDeviceGetClockOffsets.Unlock()
	return mock.DeviceGetClockOffsetsFunc(device)
}

// DeviceGetClockOffsetsCalls gets all the calls that were made to DeviceGetClockOffsets.
// Check the length with:
//
//	len(mockedInterface.DeviceGetClockOffsetsCalls())
func (mock *Interface) DeviceGetClockOffsetsCalls() []struct {
	Device nvml.Device
} {
	var calls []struct {
		Device nvml.Device
	}
	mock.lockDeviceGetClockOffsets.RLock()
	calls = mock.calls.DeviceGetClockOffsets
	mock.lockDeviceGetClockOffsets.RUnlock()
	return calls
}

// DeviceGetComputeInstanceId calls DeviceGetComputeInstanceIdFunc.
func (mock *Interface) DeviceGetComputeInstanceId(device nvml.Device) (int, nvml.Return) {
	if mock.DeviceGetComputeInstanceIdFunc == nil {
		panic("Interface.DeviceGetComputeInstanceIdFunc: method is nil but Interface.DeviceGetComputeInstanceId was just called")
	}
	callInfo := struct {
		Device nvml.Device
	}{
		Device: device,
	}
	mock.lockDeviceGetComputeInstanceId.Lock()
	mock.calls.DeviceGetComputeInstanceId = append(mock.calls.DeviceGetComputeInstanceId, callInfo)
	mock.lockDeviceGetComputeInstanceId.Unlock()
	return mock.DeviceGetComputeInstanceIdFunc(device)
}

// DeviceGetComputeInstanceIdCalls gets all the calls that were made to DeviceGetComputeInstanceId.
// Check the length with:
//
//	len(mockedInterface.DeviceGetComputeInstanceIdCalls())
func (mock *Interface) DeviceGetComputeInstanceIdCalls() []struct {
	Device nvml.Device
} {
	var calls []struct {
		Device nvml.Device
	}
	mock.lockDeviceGetComputeInstanceId.RLock()
	calls = mock.calls.DeviceGetComputeInstanceId
	mock.lockDeviceGetComputeInstanceId.RUnlock()
	return calls
}

// DeviceGetComputeMode calls DeviceGetComputeModeFunc.
func (mock *Interface) DeviceGetComputeMode(device nvml.Device) (nvml.ComputeMode, nvml.Return) {
	if mock.DeviceGetComputeModeFunc == nil {
		panic("Interface.DeviceGetComputeModeFunc: method is nil but Interface.DeviceGetComputeMode was just called")
	}
	callInfo := struct {
		Device nvml.Device
	}{
		Device: device,
	}
	mock.lockDeviceGetComputeMode.Lock()
	mock.calls.DeviceGetComputeMode = append(mock.calls.DeviceGetComputeMode, callInfo)
	mock.lockDeviceGetComputeMode.Unlock()
	return mock.DeviceGetComputeModeFunc(device)
}

// DeviceGetComputeModeCalls gets all the calls that were made to DeviceGetComputeMode.
// Check the length with:
//
//	len(mockedInterface.DeviceGetComputeModeCalls())
func (mock *Interface) DeviceGetComputeModeCalls() []struct {
	Device nvml.Device
} {
	var calls []struct {
		Device nvml.Device
	}
	mock.lockDeviceGetComputeMode.RLock()
	calls = mock.calls.DeviceGetComputeMode
	mock.lockDeviceGetComputeMode.RUnlock()
	return calls
}

// DeviceGetComputeRunningProcesses calls DeviceGetComputeRunningProcessesFunc.
func (mock *Interface) DeviceGetComputeRunningProcesses(device nvml.Device) ([]nvml.ProcessInfo, nvml.Return) {
	if mock.DeviceGetComputeRunningProcessesFunc == nil {
		panic("Interface.DeviceGetComputeRunningProcessesFunc: method is nil but Interface.DeviceGetComputeRunningProcesses was just called")
	}
	callInfo := struct {
		Device nvml.Device
	}{
		Device: device,
	}
	mock.lockDeviceGetComputeRunningProcesses.Lock()
	mock.calls.DeviceGetComputeRunningProcesses = append(mock.calls.DeviceGetComputeRunningProcesses, callInfo)
	mock.lockDeviceGetComputeRunningProcesses.Unlock()
	return mock.DeviceGetComputeRunningProcessesFunc(device)
}

// DeviceGetComputeRunningProcessesCalls gets all the calls that were made to DeviceGetComputeRunningProcesses.
// Check the length with:
//
//	len(mockedInterface.DeviceGetComputeRunningProcessesCalls())
func (mock *Interface) DeviceGetComputeRunningProcessesCalls() []struct {
	Device nvml.Device
} {
	var calls []struct {
		Device nvml.Device
	}
	mock.lockDeviceGetComputeRunningProcesses.RLock()
	calls = mock.calls.DeviceGetComputeRunningProcesses
	mock.lockDeviceGetComputeRunningProcesses.RUnlock()
	return calls
}

// DeviceGetConfComputeGpuAttestationReport calls DeviceGetConfComputeGpuAttestationReportFunc.
func (mock *Interface) DeviceGetConfComputeGpuAttestationReport(device nvml.Device, confComputeGpuAttestationReport *nvml.ConfComputeGpuAttestationReport) nvml.Return {
	if mock.DeviceGetConfComputeGpuAttestationReportFunc == nil {
		panic("Interface.DeviceGetConfComputeGpuAttestationReportFunc: method is nil but Interface.DeviceGetConfComputeGpuAttestationReport was just called")
	}
	callInfo := struct {
		Device                          nvml.Device
		ConfComputeGpuAttestationReport *nvml.ConfComputeGpuAttestationReport
	}{
		Device:                          device,
		ConfComputeGpuAttestationReport: confComputeGpuAttestationReport,
	}
	mock.lockDeviceGetConfComputeGpuAttestationReport.Lock()
	mock.calls.DeviceGetConfComputeGpuAttestationReport = append(mock.calls.DeviceGetConfComputeGpuAttestationReport, callInfo)
	mock.lockDeviceGetConfComputeGpuAttestationReport.Unlock()
	return mock.DeviceGetConfComputeGpuAttestationReportFunc(device, confComputeGpuAttestationReport)
}

// DeviceGetConfComputeGpuAttestationReportCalls gets all the calls that were made to DeviceGetConfComputeGpuAttestationReport.
// Check the length with:
//
//	len(mockedInterface.DeviceGetConfComputeGpuAttestationReportCalls())
func (mock *Interface) DeviceGetConfComputeGpuAttestationReportCalls() []struct {
	Device                          nvml.Device
	ConfComputeGpuAttestationReport *nvml.ConfComputeGpuAttestationReport
} {
	var calls []struct {
		Device                          nvml.Device
		ConfComputeGpuAttestationReport *nvml.ConfComputeGpuAttestationReport
	}
	mock.lockDeviceGetConfComputeGpuAttestationReport.RLock()
	calls = mock.calls.DeviceGetConfComputeGpuAttestationReport
	mock.lockDeviceGetConfComputeGpuAttestationReport.RUnlock()
	return calls
}

// DeviceGetConfComputeGpuCertificate calls DeviceGetConfComputeGpuCertificateFunc.
func (mock *Interface) DeviceGetConfComputeGpuCertificate(device nvml.Device) (nvml.ConfComputeGpuCertificate, nvml.Return) {
	if mock.DeviceGetConfComputeGpuCertificateFunc == nil {
		panic("Interface.DeviceGetConfComputeGpuCertificateFunc: method is nil but Interface.DeviceGetConfComputeGpuCertificate was just called")
	}
	callInfo := struct {
		Device nvml.Device
	}{
		Device: device,
	}
	mock.lockDeviceGetConfComputeGpuCertificate.Lock()
	mock.calls.DeviceGetConfComputeGpuCertificate = append(mock.calls.DeviceGetConfComputeGpuCertificate, callInfo)
	mock.lockDeviceGetConfComputeGpuCertificate.Unlock()
	return mock.DeviceGetConfComputeGpuCertificateFunc(device)
}

// DeviceGetConfComputeGpuCertificateCalls gets all the calls that were made to DeviceGetConfComputeGpuCertificate.
// Check the length with:
//
//	len(mockedInterface.DeviceGetConfComputeGpuCertificateCalls())
func (mock *Interface) DeviceGetConfComputeGpuCertificateCalls() []struct {
	Device nvml.Device
} {
	var calls []struct {
		Device nvml.Device
	}
	mock.lockDeviceGetConfComputeGpuCertificate.RLock()
	calls = mock.calls.DeviceGetConfComputeGpuCertificate
	mock.lockDeviceGetConfComputeGpuCertificate.RUnlock()
	return calls
}

// DeviceGetConfComputeMemSizeInfo calls DeviceGetConfComputeMemSizeInfoFunc.
func (mock *Interface) DeviceGetConfComputeMemSizeInfo(device nvml.Device) (nvml.ConfComputeMemSizeInfo, nvml.Return) {
	if mock.DeviceGetConfComputeMemSizeInfoFunc == nil {
		panic("Interface.DeviceGetConfComputeMemSizeInfoFunc: method is nil but Interface.DeviceGetConfComputeMemSizeInfo was just called")
	}
	callInfo := struct {
		Device nvml.Device
	}{
		Device: device,
	}
	mock.lockDeviceGetConfComputeMemSizeInfo.Lock()
	mock.calls.DeviceGetConfComputeMemSizeInfo = append(mock.calls.DeviceGetConfComputeMemSizeInfo, callInfo)
	mock.lockDeviceGetConfComputeMemSizeInfo.Unlock()
	return mock.DeviceGetConfComputeMemSizeInfoFunc(device)
}

// DeviceGetConfComputeMemSizeInfoCalls gets all the calls that were made to DeviceGetConfComputeMemSizeInfo.
// Check the length with:
//
//	len(mockedInterface.DeviceGetConfComputeMemSizeInfoCalls())
func (mock *Interface) DeviceGetConfComputeMemSizeInfoCalls() []struct {
	Device nvml.Device
} {
	var calls []struct {
		Device nvml.Device
	}
	mock.lockDeviceGetConfComputeMemSizeInfo.RLock()
	calls = mock.calls.DeviceGetConfComputeMemSizeInfo
	mock.lockDeviceGetConfComputeMemSizeInfo.RUnlock()
	return calls
}

// DeviceGetConfComputeProtectedMemoryUsage calls DeviceGetConfComputeProtectedMemoryUsageFunc.
func (mock *Interface) DeviceGetConfComputeProtectedMemoryUsage(device nvml.Device) (nvml.Memory, nvml.Return) {
	if mock.DeviceGetConfComputeProtectedMemoryUsageFunc == nil {
		panic("Interface.DeviceGetConfComputeProtectedMemoryUsageFunc: method is nil but Interface.DeviceGetConfComputeProtectedMemoryUsage was just called")
	}
	callInfo := struct {
		Device nvml.Device
	}{
		Device: device,
	}
	mock.lockDeviceGetConfComputeProtectedMemoryUsage.Lock()
	mock.calls.DeviceGetConfComputeProtectedMemoryUsage = append(mock.calls.DeviceGetConfComputeProtectedMemoryUsage, callInfo)
	mock.lockDeviceGetConfComputeProtectedMemoryUsage.Unlock()
	return mock.DeviceGetConfComputeProtectedMemoryUsageFunc(device)
}

// DeviceGetConfComputeProtectedMemoryUsageCalls gets all the calls that were made to DeviceGetConfComputeProtectedMemoryUsage.
// Check the length with:
//
//	len(mockedInterface.DeviceGetConfComputeProtectedMemoryUsageCalls())
func (mock *Interface) DeviceGetConfComputeProtectedMemoryUsageCalls() []struct {
	Device nvml.Device
} {
	var calls []struct {
		Device nvml.Device
	}
	mock.lockDeviceGetConfComputeProtectedMemoryUsage.RLock()
	calls = mock.calls.DeviceGetConfComputeProtectedMemoryUsage
	mock.lockDeviceGetConfComputeProtectedMemoryUsage.RUnlock()
	return calls
}

// DeviceGetCoolerInfo calls DeviceGetCoolerInfoFunc.
func (mock *Interface) DeviceGetCoolerInfo(device nvml.Device) (nvml.CoolerInfo, nvml.Return) {
	if mock.DeviceGetCoolerInfoFunc == nil {
		panic("Interface.DeviceGetCoolerInfoFunc: method is nil but Interface.DeviceGetCoolerInfo was just called")
	}
	callInfo := struct {
		Device nvml.Device
	}{
		Device: device,
	}
	mock.lockDeviceGetCoolerInfo.Lock()
	mock.calls.DeviceGetCoolerInfo = append(mock.calls.DeviceGetCoolerInfo, callInfo)
	mock.lockDeviceGetCoolerInfo.Unlock()
	return mock.DeviceGetCoolerInfoFunc(device)
}

// DeviceGetCoolerInfoCalls gets all the calls that were made to DeviceGetCoolerInfo.
// Check the length with:
//
//	len(mockedInterface.DeviceGetCoolerInfoCalls())
func (mock *Interface) DeviceGetCoolerInfoCalls() []struct {
	Device nvml.Device
} {
	var calls []struct {
		Device nvml.Device
	}
	mock.lockDeviceGetCoolerInfo.RLock()
	calls = mock.calls.DeviceGetCoolerInfo
	mock.lockDeviceGetCoolerInfo.RUnlock()
	return calls
}

// DeviceGetCount calls DeviceGetCountFunc.
func (mock *Interface) DeviceGetCount() (int, nvml.Return) {
	if mock.DeviceGetCountFunc == nil {
		panic("Interface.DeviceGetCountFunc: method is nil but Interface.DeviceGetCount was just called")
	}
	callInfo := struct {
	}{}
	mock.lockDeviceGetCount.Lock()
	mock.calls.DeviceGetCount = append(mock.calls.DeviceGetCount, callInfo)
	mock.lockDeviceGetCount.Unlock()
	return mock.DeviceGetCountFunc()
}

// DeviceGetCountCalls gets all the calls that were made to DeviceGetCount.
// Check the length with:
//
//	len(mockedInterface.DeviceGetCountCalls())
func (mock *Interface) DeviceGetCountCalls() []struct {
} {
	var calls []struct {
	}
	mock.lockDeviceGetCount.RLock()
	calls = mock.calls.DeviceGetCount
	mock.lockDeviceGetCount.RUnlock()
	return calls
}

// DeviceGetCpuAffinity calls DeviceGetCpuAffinityFunc.
func (mock *Interface) DeviceGetCpuAffinity(device nvml.Device, n int) ([]uint, nvml.Return) {
	if mock.DeviceGetCpuAffinityFunc == nil {
		panic("Interface.DeviceGetCpuAffinityFunc: method is nil but Interface.DeviceGetCpuAffinity was just called")
	}
	callInfo := struct {
		Device nvml.Device
		N      int
	}{
		Device: device,
		N:      n,
	}
	mock.lockDeviceGetCpuAffinity.Lock()
	mock.calls.DeviceGetCpuAffinity = append(mock.calls.DeviceGetCpuAffinity, callInfo)
	mock.lockDeviceGetCpuAffinity.Unlock()
	return mock.DeviceGetCpuAffinityFunc(device, n)
}

// DeviceGetCpuAffinityCalls gets all the calls that were made to DeviceGetCpuAffinity.
// Check the length with:
//
//	len(mockedInterface.DeviceGetCpuAffinityCalls())
func (mock *Interface) DeviceGetCpuAffinityCalls() []struct {
	Device nvml.Device
	N      int
} {
	var calls []struct {
		Device nvml.Device
		N      int
	}
	mock.lockDeviceGetCpuAffinity.RLock()
	calls = mock.calls.DeviceGetCpuAffinity
	mock.lockDeviceGetCpuAffinity.RUnlock()
	return calls
}

// DeviceGetCpuAffinityWithinScope calls DeviceGetCpuAffinityWithinScopeFunc.
func (mock *Interface) DeviceGetCpuAffinityWithinScope(device nvml.Device, n int, affinityScope nvml.AffinityScope) ([]uint, nvml.Return) {
	if mock.DeviceGetCpuAffinityWithinScopeFunc == nil {
		panic("Interface.DeviceGetCpuAffinityWithinScopeFunc: method is nil but Interface.DeviceGetCpuAffinityWithinScope was just called")
	}
	callInfo := struct {
		Device        nvml.Device
		N             int
		AffinityScope nvml.AffinityScope
	}{
		Device:        device,
		N:             n,
		AffinityScope: affinityScope,
	}
	mock.lockDeviceGetCpuAffinityWithinScope.Lock()
	mock.calls.DeviceGetCpuAffinityWithinScope = append(mock.calls.DeviceGetCpuAffinityWithinScope, callInfo)
	mock.lockDeviceGetCpuAffinityWithinScope.Unlock()
	return mock.DeviceGetCpuAffinityWithinScopeFunc(device, n, affinityScope)
}

// DeviceGetCpuAffinityWithinScopeCalls gets all the calls that were made to DeviceGetCpuAffinityWithinScope.
// Check the length with:
//
//	len(mockedInterface.DeviceGetCpuAffinityWithinScopeCalls())
func (mock *Interface) DeviceGetCpuAffinityWithinScopeCalls() []struct {
	Device        nvml.Device
	N             int
	AffinityScope nvml.AffinityScope
} {
	var calls []struct {
		Device        nvml.Device
		N             int
		AffinityScope nvml.AffinityScope
	}
	mock.lockDeviceGetCpuAffinityWithinScope.RLock()
	calls = mock.calls.DeviceGetCpuAffinityWithinScope
	mock.lockDeviceGetCpuAffinityWithinScope.RUnlock()
	return calls
}

// DeviceGetCreatableVgpus calls DeviceGetCreatableVgpusFunc.
func (mock *Interface) DeviceGetCreatableVgpus(device nvml.Device) ([]nvml.VgpuTypeId, nvml.Return) {
	if mock.DeviceGetCreatableVgpusFunc == nil {
		panic("Interface.DeviceGetCreatableVgpusFunc: method is nil but Interface.DeviceGetCreatableVgpus was just called")
	}
	callInfo := struct {
		Device nvml.Device
	}{
		Device: device,
	}
	mock.lockDeviceGetCreatableVgpus.Lock()
	mock.calls.DeviceGetCreatableVgpus = append(mock.calls.DeviceGetCreatableVgpus, callInfo)
	mock.lockDeviceGetCreatableVgpus.Unlock()
	return mock.DeviceGetCreatableVgpusFunc(device)
}

// DeviceGetCreatableVgpusCalls gets all the calls that were made to DeviceGetCreatableVgpus.
// Check the length with:
//
//	len(mockedInterface.DeviceGetCreatableVgpusCalls())
func (mock *Interface) DeviceGetCreatableVgpusCalls() []struct {
	Device nvml.Device
} {
	var calls []struct {
		Device nvml.Device
	}
	mock.lockDeviceGetCreatableVgpus.RLock()
	calls = mock.calls.DeviceGetCreatableVgpus
	mock.lockDeviceGetCreatableVgpus.RUnlock()
	return calls
}

// DeviceGetCudaComputeCapability calls DeviceGetCudaComputeCapabilityFunc.
func (mock *Interface) DeviceGetCudaComputeCapability(device nvml.Device) (int, int, nvml.Return) {
	if mock.DeviceGetCudaComputeCapabilityFunc == nil {
		panic("Interface.DeviceGetCudaComputeCapabilityFunc: method is nil but Interface.DeviceGetCudaComputeCapability was just called")
	}
	callInfo := struct {
		Device nvml.Device
	}{
		Device: device,
	}
	mock.lockDeviceGetCudaComputeCapability.Lock()
	mock.calls.DeviceGetCudaComputeCapability = append(mock.calls.DeviceGetCudaComputeCapability, callInfo)
	mock.lockDeviceGetCudaComputeCapability.Unlock()
	return mock.DeviceGetCudaComputeCapabilityFunc(device)
}

// DeviceGetCudaComputeCapabilityCalls gets all the calls that were made to DeviceGetCudaComputeCapability.
// Check the length with:
//
//	len(mockedInterface.DeviceGetCudaComputeCapabilityCalls())
func (mock *Interface) DeviceGetCudaComputeCapabilityCalls() []struct {
	Device nvml.Device
} {
	var calls []struct {
		Device nvml.Device
	}
	mock.lockDeviceGetCudaComputeCapability.RLock()
	calls = mock.calls.DeviceGetCudaComputeCapability
	mock.lockDeviceGetCudaComputeCapability.RUnlock()
	return calls
}

// DeviceGetCurrPcieLinkGeneration calls DeviceGetCurrPcieLinkGenerationFunc.
func (mock *Interface) DeviceGetCurrPcieLinkGeneration(device nvml.Device) (int, nvml.Return) {
	if mock.DeviceGetCurrPcieLinkGenerationFunc == nil {
		panic("Interface.DeviceGetCurrPcieLinkGenerationFunc: method is nil but Interface.DeviceGetCurrPcieLinkGeneration was just called")
	}
	callInfo := struct {
		Device nvml.Device
	}{
		Device: device,
	}
	mock.lockDeviceGetCurrPcieLinkGeneration.Lock()
	mock.calls.DeviceGetCurrPcieLinkGeneration = append(mock.calls.DeviceGetCurrPcieLinkGeneration, callInfo)
	mock.lockDeviceGetCurrPcieLinkGeneration.Unlock()
	return mock.DeviceGetCurrPcieLinkGenerationFunc(device)
}

// DeviceGetCurrPcieLinkGenerationCalls gets all the calls that were made to DeviceGetCurrPcieLinkGeneration.
// Check the length with:
//
//	len(mockedInterface.DeviceGetCurrPcieLinkGenerationCalls())
func (mock *Interface) DeviceGetCurrPcieLinkGenerationCalls() []struct {
	Device nvml.Device
} {
	var calls []struct {
		Device nvml.Device
	}
	mock.lockDeviceGetCurrPcieLinkGeneration.RLock()
	calls = mock.calls.DeviceGetCurrPcieLinkGeneration
	mock.lockDeviceGetCurrPcieLinkGeneration.RUnlock()
	return calls
}

// DeviceGetCurrPcieLinkWidth calls DeviceGetCurrPcieLinkWidthFunc.
func (mock *Interface) DeviceGetCurrPcieLinkWidth(device nvml.Device) (int, nvml.Return) {
	if mock.DeviceGetCurrPcieLinkWidthFunc == nil {
		panic("Interface.DeviceGetCurrPcieLinkWidthFunc: method is nil but Interface.DeviceGetCurrPcieLinkWidth was just called")
	}
	callInfo := struct {
		Device nvml.Device
	}{
		Device: device,
	}
	mock.lockDeviceGetCurrPcieLinkWidth.Lock()
	mock.calls.DeviceGetCurrPcieLinkWidth = append(mock.calls.DeviceGetCurrPcieLinkWidth, callInfo)
	mock.lockDeviceGetCurrPcieLinkWidth.Unlock()
	return mock.DeviceGetCurrPcieLinkWidthFunc(device)
}

// DeviceGetCurrPcieLinkWidthCalls gets all the calls that were made to DeviceGetCurrPcieLinkWidth.
// Check the length with:
//
//	len(mockedInterface.DeviceGetCurrPcieLinkWidthCalls())
func (mock *Interface) DeviceGetCurrPcieLinkWidthCalls() []struct {
	Device nvml.Device
} {
	var calls []struct {
		Device nvml.Device
	}
	mock.lockDeviceGetCurrPcieLinkWidth.RLock()
	calls = mock.calls.DeviceGetCurrPcieLinkWidth
	mock.lockDeviceGetCurrPcieLinkWidth.RUnlock()
	return calls
}

// DeviceGetCurrentClockFreqs calls DeviceGetCurrentClockFreqsFunc.
func (mock *Interface) DeviceGetCurrentClockFreqs(device nvml.Device) (nvml.DeviceCurrentClockFreqs, nvml.Return) {
	if mock.DeviceGetCurrentClockFreqsFunc == nil {
		panic("Interface.DeviceGetCurrentClockFreqsFunc: method is nil but Interface.DeviceGetCurrentClockFreqs was just called")
	}
	callInfo := struct {
		Device nvml.Device
	}{
		Device: device,
	}
	mock.lockDeviceGetCurrentClockFreqs.Lock()
	mock.calls.DeviceGetCurrentClockFreqs = append(mock.calls.DeviceGetCurrentClockFreqs, callInfo)
	mock.lockDeviceGetCurrentClockFreqs.Unlock()
	return mock.DeviceGetCurrentClockFreqsFunc(device)
}

// DeviceGetCurrentClockFreqsCalls gets all the calls that were made to DeviceGetCurrentClockFreqs.
// Check the length with:
//
//	len(mockedInterface.DeviceGetCurrentClockFreqsCalls())
func (mock *Interface) DeviceGetCurrentClockFreqsCalls() []struct {
	Device nvml.Device
} {
	var calls []struct {
		Device nvml.Device
	}
	mock.lockDeviceGetCurrentClockFreqs.RLock()
	calls = mock.calls.DeviceGetCurrentClockFreqs
	mock.lockDeviceGetCurrentClockFreqs.RUnlock()
	return calls
}

// DeviceGetCurrentClocksEventReasons calls DeviceGetCurrentClocksEventReasonsFunc.
func (mock *Interface) DeviceGetCurrentClocksEventReasons(device nvml.Device) (uint64, nvml.Return) {
	if mock.DeviceGetCurrentClocksEventReasonsFunc == nil {
		panic("Interface.DeviceGetCurrentClocksEventReasonsFunc: method is nil but Interface.DeviceGetCurrentClocksEventReasons was just called")
	}
	callInfo := struct {
		Device nvml.Device
	}{
		Device: device,
	}
	mock.lockDeviceGetCurrentClocksEventReasons.Lock()
	mock.calls.DeviceGetCurrentClocksEventReasons = append(mock.calls.DeviceGetCurrentClocksEventReasons, callInfo)
	mock.lockDeviceGetCurrentClocksEventReasons.Unlock()
	return mock.DeviceGetCurrentClocksEventReasonsFunc(device)
}

// DeviceGetCurrentClocksEventReasonsCalls gets all the calls that were made to DeviceGetCurrentClocksEventReasons.
// Check the length with:
//
//	len(mockedInterface.DeviceGetCurrentClocksEventReasonsCalls())
func (mock *Interface) DeviceGetCurrentClocksEventReasonsCalls() []struct {
	Device nvml.Device
} {
	var calls []struct {
		Device nvml.Device
	}
	mock.lockDeviceGetCurrentClocksEventReasons.RLock()
	calls = mock.calls.DeviceGetCurrentClocksEventReasons
	mock.lockDeviceGetCurrentClocksEventReasons.RUnlock()
	return calls
}

// DeviceGetCurrentClocksThrottleReasons calls DeviceGetCurrentClocksThrottleReasonsFunc.
func (mock *Interface) DeviceGetCurrentClocksThrottleReasons(device nvml.Device) (uint64, nvml.Return) {
	if mock.DeviceGetCurrentClocksThrottleReasonsFunc == nil {
		panic("Interface.DeviceGetCurrentClocksThrottleReasonsFunc: method is nil but Interface.DeviceGetCurrentClocksThrottleReasons was just called")
	}
	callInfo := struct {
		Device nvml.Device
	}{
		Device: device,
	}
	mock.lockDeviceGetCurrentClocksThrottleReasons.Lock()
	mock.calls.DeviceGetCurrentClocksThrottleReasons = append(mock.calls.DeviceGetCurrentClocksThrottleReasons, callInfo)
	mock.lockDeviceGetCurrentClocksThrottleReasons.Unlock()
	return mock.DeviceGetCurrentClocksThrottleReasonsFunc(device)
}

// DeviceGetCurrentClocksThrottleReasonsCalls gets all the calls that were made to DeviceGetCurrentClocksThrottleReasons.
// Check the length with:
//
//	len(mockedInterface.DeviceGetCurrentClocksThrottleReasonsCalls())
func (mock *Interface) DeviceGetCurrentClocksThrottleReasonsCalls() []struct {
	Device nvml.Device
} {
	var calls []struct {
		Device nvml.Device
	}
	mock.lockDeviceGetCurrentClocksThrottleReasons.RLock()
	calls = mock.calls.DeviceGetCurrentClocksThrottleReasons
	mock.lockDeviceGetCurrentClocksThrottleReasons.RUnlock()
	return calls
}

// DeviceGetDecoderUtilization calls DeviceGetDecoderUtilizationFunc.
func (mock *Interface) DeviceGetDecoderUtilization(device nvml.Device) (uint32, uint32, nvml.Return) {
	if mock.DeviceGetDecoderUtilizationFunc == nil {
		panic("Interface.DeviceGetDecoderUtilizationFunc: method is nil but Interface.DeviceGetDecoderUtilization was just called")
	}
	callInfo := struct {
		Device nvml.Device
	}{
		Device: device,
	}
	mock.lockDeviceGetDecoderUtilization.Lock()
	mock.calls.DeviceGetDecoderUtilization = append(mock.calls.DeviceGetDecoderUtilization, callInfo)
	mock.lockDeviceGetDecoderUtilization.Unlock()
	return mock.DeviceGetDecoderUtilizationFunc(device)
}

// DeviceGetDecoderUtilizationCalls gets all the calls that were made to DeviceGetDecoderUtilization.
// Check the length with:
//
//	len(mockedInterface.DeviceGetDecoderUtilizationCalls())
func (mock *Interface) DeviceGetDecoderUtilizationCalls() []struct {
	Device nvml.Device
} {
	var calls []struct {
		Device nvml.Device
	}
	mock.lockDeviceGetDecoderUtilization.RLock()
	calls = mock.calls.DeviceGetDecoderUtilization
	mock.lockDeviceGetDecoderUtilization.RUnlock()
	return calls
}

// DeviceGetDefaultApplicationsClock calls DeviceGetDefaultApplicationsClockFunc.
func (mock *Interface) DeviceGetDefaultApplicationsClock(device nvml.Device, clockType nvml.ClockType) (uint32, nvml.Return) {
	if mock.DeviceGetDefaultApplicationsClockFunc == nil {
		panic("Interface.DeviceGetDefaultApplicationsClockFunc: method is nil but Interface.DeviceGetDefaultApplicationsClock was just called")
	}
	callInfo := struct {
		Device    nvml.Device
		ClockType nvml.ClockType
	}{
		Device:    device,
		ClockType: clockType,
	}
	mock.lockDeviceGetDefaultApplicationsClock.Lock()
	mock.calls.DeviceGetDefaultApplicationsClock = append(mock.calls.DeviceGetDefaultApplicationsClock, callInfo)
	mock.lockDeviceGetDefaultApplicationsClock.Unlock()
	return mock.DeviceGetDefaultApplicationsClockFunc(device, clockType)
}

// DeviceGetDefaultApplicationsClockCalls gets all the calls that were made to DeviceGetDefaultApplicationsClock.
// Check the length with:
//
//	len(mockedInterface.DeviceGetDefaultApplicationsClockCalls())
func (mock *Interface) DeviceGetDefaultApplicationsClockCalls() []struct {
	Device    nvml.Device
	ClockType nvml.ClockType
} {
	var calls []struct {
		Device    nvml.Device
		ClockType nvml.ClockType
	}
	mock.lockDeviceGetDefaultApplicationsClock.RLock()
	calls = mock.calls.DeviceGetDefaultApplicationsClock
	mock.lockDeviceGetDefaultApplicationsClock.RUnlock()
	return calls
}

// DeviceGetDefaultEccMode calls DeviceGetDefaultEccModeFunc.
func (mock *Interface) DeviceGetDefaultEccMode(device nvml.Device) (nvml.EnableState, nvml.Return) {
	if mock.DeviceGetDefaultEccModeFunc == nil {
		panic("Interface.DeviceGetDefaultEccModeFunc: method is nil but Interface.DeviceGetDefaultEccMode was just called")
	}
	callInfo := struct {
		Device nvml.Device
	}{
		Device: device,
	}
	mock.lockDeviceGetDefaultEccMode.Lock()
	mock.calls.DeviceGetDefaultEccMode = append(mock.calls.DeviceGetDefaultEccMode, callInfo)
	mock.lockDeviceGetDefaultEccMode.Unlock()
	return mock.DeviceGetDefaultEccModeFunc(device)
}

// DeviceGetDefaultEccModeCalls gets all the calls that were made to DeviceGetDefaultEccMode.
// Check the length with:
//
//	len(mockedInterface.DeviceGetDefaultEccModeCalls())
func (mock *Interface) DeviceGetDefaultEccModeCalls() []struct {
	Device nvml.Device
} {
	var calls []struct {
		Device nvml.Device
	}
	mock.lockDeviceGetDefaultEccMode.RLock()
	calls = mock.calls.DeviceGetDefaultEccMode
	mock.lockDeviceGetDefaultEccMode.RUnlock()
	return calls
}

// DeviceGetDetailedEccErrors calls DeviceGetDetailedEccErrorsFunc.
func (mock *Interface) DeviceGetDetailedEccErrors(device nvml.Device, memoryErrorType nvml.MemoryErrorType, eccCounterType nvml.EccCounterType) (nvml.EccErrorCounts, nvml.Return) {
	if mock.DeviceGetDetailedEccErrorsFunc == nil {
		panic("Interface.DeviceGetDetailedEccErrorsFunc: method is nil but Interface.DeviceGetDetailedEccErrors was just called")
	}
	callInfo := struct {
		Device          nvml.Device
		MemoryErrorType nvml.MemoryErrorType
		EccCounterType  nvml.EccCounterType
	}{
		Device:          device,
		MemoryErrorType: memoryErrorType,
		EccCounterType:  eccCounterType,
	}
	mock.lockDeviceGetDetailedEccErrors.Lock()
	mock.calls.DeviceGetDetailedEccErrors = append(mock.calls.DeviceGetDetailedEccErrors, callInfo)
	mock.lockDeviceGetDetailedEccErrors.Unlock()
	return mock.DeviceGetDetailedEccErrorsFunc(device, memoryErrorType, eccCounterType)
}

// DeviceGetDetailedEccErrorsCalls gets all the calls that were made to DeviceGetDetailedEccErrors.
// Check the length with:
//
//	len(mockedInterface.DeviceGetDetailedEccErrorsCalls())
func (mock *Interface) DeviceGetDetailedEccErrorsCalls() []struct {
	Device          nvml.Device
	MemoryErrorType nvml.MemoryErrorType
	EccCounterType  nvml.EccCounterType
} {
	var calls []struct {
		Device          nvml.Device
		MemoryErrorType nvml.MemoryErrorType
		EccCounterType  nvml.EccCounterType
	}
	mock.lockDeviceGetDetailedEccErrors.RLock()
	calls = mock.calls.DeviceGetDetailedEccErrors
	mock.lockDeviceGetDetailedEccErrors.RUnlock()
	return calls
}

// DeviceGetDeviceHandleFromMigDeviceHandle calls DeviceGetDeviceHandleFromMigDeviceHandleFunc.
func (mock *Interface) DeviceGetDeviceHandleFromMigDeviceHandle(device nvml.Device) (nvml.Device, nvml.Return) {
	if mock.DeviceGetDeviceHandleFromMigDeviceHandleFunc == nil {
		panic("Interface.DeviceGetDeviceHandleFromMigDeviceHandleFunc: method is nil but Interface.DeviceGetDeviceHandleFromMigDeviceHandle was just called")
	}
	callInfo := struct {
		Device nvml.Device
	}{
		Device: device,
	}
	mock.lockDeviceGetDeviceHandleFromMigDeviceHandle.Lock()
	mock.calls.DeviceGetDeviceHandleFromMigDeviceHandle = append(mock.calls.DeviceGetDeviceHandleFromMigDeviceHandle, callInfo)
	mock.lockDeviceGetDeviceHandleFromMigDeviceHandle.Unlock()
	return mock.DeviceGetDeviceHandleFromMigDeviceHandleFunc(device)
}

// DeviceGetDeviceHandleFromMigDeviceHandleCalls gets all the calls that were made to DeviceGetDeviceHandleFromMigDeviceHandle.
// Check the length with:
//
//	len(mockedInterface.DeviceGetDeviceHandleFromMigDeviceHandleCalls())
func (mock *Interface) DeviceGetDeviceHandleFromMigDeviceHandleCalls() []struct {
	Device nvml.Device
} {
	var calls []struct {
		Device nvml.Device
	}
	mock.lockDeviceGetDeviceHandleFromMigDeviceHandle.RLock()
	calls = mock.calls.DeviceGetDeviceHandleFromMigDeviceHandle
	mock.lockDeviceGetDeviceHandleFromMigDeviceHandle.RUnlock()
	return calls
}

// DeviceGetDisplayActive calls DeviceGetDisplayActiveFunc.
func (mock *Interface) DeviceGetDisplayActive(device nvml.Device) (nvml.EnableState, nvml.Return) {
	if mock.DeviceGetDisplayActiveFunc == nil {
		panic("Interface.DeviceGetDisplayActiveFunc: method is nil but Interface.DeviceGetDisplayActive was just called")
	}
	callInfo := struct {
		Device nvml.Device
	}{
		Device: device,
	}
	mock.lockDeviceGetDisplayActive.Lock()
	mock.calls.DeviceGetDisplayActive = append(mock.calls.DeviceGetDisplayActive, callInfo)
	mock.lockDeviceGetDisplayActive.Unlock()
	return mock.DeviceGetDisplayActiveFunc(device)
}

// DeviceGetDisplayActiveCalls gets all the calls that were made to DeviceGetDisplayActive.
// Check the length with:
//
//	len(mockedInterface.DeviceGetDisplayActiveCalls())
func (mock *Interface) DeviceGetDisplayActiveCalls() []struct {
	Device nvml.Device
} {
	var calls []struct {
		Device nvml.Device
	}
	mock.lockDeviceGetDisplayActive.RLock()
	calls = mock.calls.DeviceGetDisplayActive
	mock.lockDeviceGetDisplayActive.RUnlock()
	return calls
}

// DeviceGetDisplayMode calls DeviceGetDisplayModeFunc.
func (mock *Interface) DeviceGetDisplayMode(device nvml.Device) (nvml.EnableState, nvml.Return) {
	if mock.DeviceGetDisplayModeFunc == nil {
		panic("Interface.DeviceGetDisplayModeFunc: method is nil but Interface.DeviceGetDisplayMode was just called")
	}
	callInfo := struct {
		Device nvml.Device
	}{
		Device: device,
	}
	mock.lockDeviceGetDisplayMode.Lock()
	mock.calls.DeviceGetDisplayMode = append(mock.calls.DeviceGetDisplayMode, callInfo)
	mock.lockDeviceGetDisplayMode.Unlock()
	return mock.DeviceGetDisplayModeFunc(device)
}

// DeviceGetDisplayModeCalls gets all the calls that were made to DeviceGetDisplayMode.
// Check the length with:
//
//	len(mockedInterface.DeviceGetDisplayModeCalls())
func (mock *Interface) DeviceGetDisplayModeCalls() []struct {
	Device nvml.Device
} {
	var calls []struct {
		Device nvml.Device
	}
	mock.lockDeviceGetDisplayMode.RLock()
	calls = mock.calls.DeviceGetDisplayMode
	mock.lockDeviceGetDisplayMode.RUnlock()
	return calls
}

// DeviceGetDramEncryptionMode calls DeviceGetDramEncryptionModeFunc.
func (mock *Interface) DeviceGetDramEncryptionMode(device nvml.Device) (nvml.DramEncryptionInfo, nvml.DramEncryptionInfo, nvml.Return) {
	if mock.DeviceGetDramEncryptionModeFunc == nil {
		panic("Interface.DeviceGetDramEncryptionModeFunc: method is nil but Interface.DeviceGetDramEncryptionMode was just called")
	}
	callInfo := struct {
		Device nvml.Device
	}{
		Device: device,
	}
	mock.lockDeviceGetDramEncryptionMode.Lock()
	mock.calls.DeviceGetDramEncryptionMode = append(mock.calls.DeviceGetDramEncryptionMode, callInfo)
	mock.lockDeviceGetDramEncryptionMode.Unlock()
	return mock.DeviceGetDramEncryptionModeFunc(device)
}

// DeviceGetDramEncryptionModeCalls gets all the calls that were made to DeviceGetDramEncryptionMode.
// Check the length with:
//
//	len(mockedInterface.DeviceGetDramEncryptionModeCalls())
func (mock *Interface) DeviceGetDramEncryptionModeCalls() []struct {
	Device nvml.Device
} {
	var calls []struct {
		Device nvml.Device
	}
	mock.lockDeviceGetDramEncryptionMode.RLock()
	calls = mock.calls.DeviceGetDramEncryptionMode
	mock.lockDeviceGetDramEncryptionMode.RUnlock()
	return calls
}

// DeviceGetDriverModel calls DeviceGetDriverModelFunc.
func (mock *Interface) DeviceGetDriverModel(device nvml.Device) (nvml.DriverModel, nvml.DriverModel, nvml.Return) {
	if mock.DeviceGetDriverModelFunc == nil {
		panic("Interface.DeviceGetDriverModelFunc: method is nil but Interface.DeviceGetDriverModel was just called")
	}
	callInfo := struct {
		Device nvml.Device
	}{
		Device: device,
	}
	mock.lockDeviceGetDriverModel.Lock()
	mock.calls.DeviceGetDriverModel = append(mock.calls.DeviceGetDriverModel, callInfo)
	mock.lockDeviceGetDriverModel.Unlock()
	return mock.DeviceGetDriverModelFunc(device)
}

// DeviceGetDriverModelCalls gets all the calls that were made to DeviceGetDriverModel.
// Check the length with:
//
//	len(mockedInterface.DeviceGetDriverModelCalls())
func (mock *Interface) DeviceGetDriverModelCalls() []struct {
	Device nvml.Device
} {
	var calls []struct {
		Device nvml.Device
	}
	mock.lockDeviceGetDriverModel.RLock()
	calls = mock.calls.DeviceGetDriverModel
	mock.lockDeviceGetDriverModel.RUnlock()
	return calls
}

// DeviceGetDriverModel_v2 calls DeviceGetDriverModel_v2Func.
func (mock *Interface) DeviceGetDriverModel_v2(device nvml.Device) (nvml.DriverModel, nvml.DriverModel, nvml.Return) {
	if mock.DeviceGetDriverModel_v2Func == nil {
		panic("Interface.DeviceGetDriverModel_v2Func: method is nil but Interface.DeviceGetDriverModel_v2 was just called")
	}
	callInfo := struct {
		Device nvml.Device
	}{
		Device: device,
	}
	mock.lockDeviceGetDriverModel_v2.Lock()
	mock.calls.DeviceGetDriverModel_v2 = append(mock.calls.DeviceGetDriverModel_v2, callInfo)
	mock.lockDeviceGetDriverModel_v2.Unlock()
	return mock.DeviceGetDriverModel_v2Func(device)
}

// DeviceGetDriverModel_v2Calls gets all the calls that were made to DeviceGetDriverModel_v2.
// Check the length with:
//
//	len(mockedInterface.DeviceGetDriverModel_v2Calls())
func (mock *Interface) DeviceGetDriverModel_v2Calls() []struct {
	Device nvml.Device
} {
	var calls []struct {
		Device nvml.Device
	}
	mock.lockDeviceGetDriverModel_v2.RLock()
	calls = mock.calls.DeviceGetDriverModel_v2
	mock.lockDeviceGetDriverModel_v2.RUnlock()
	return calls
}

// DeviceGetDynamicPstatesInfo calls DeviceGetDynamicPstatesInfoFunc.
func (mock *Interface) DeviceGetDynamicPstatesInfo(device nvml.Device) (nvml.GpuDynamicPstatesInfo, nvml.Return) {
	if mock.DeviceGetDynamicPstatesInfoFunc == nil {
		panic("Interface.DeviceGetDynamicPstatesInfoFunc: method is nil but Interface.DeviceGetDynamicPstatesInfo was just called")
	}
	callInfo := struct {
		Device nvml.Device
	}{
		Device: device,
	}
	mock.lockDeviceGetDynamicPstatesInfo.Lock()
	mock.calls.DeviceGetDynamicPstatesInfo = append(mock.calls.DeviceGetDynamicPstatesInfo, callInfo)
	mock.lockDeviceGetDynamicPstatesInfo.Unlock()
	return mock.DeviceGetDynamicPstatesInfoFunc(device)
}

// DeviceGetDynamicPstatesInfoCalls gets all the calls that were made to DeviceGetDynamicPstatesInfo.
// Check the length with:
//
//	len(mockedInterface.DeviceGetDynamicPstatesInfoCalls())
func (mock *Interface) DeviceGetDynamicPstatesInfoCalls() []struct {
	Device nvml.Device
} {
	var calls []struct {
		Device nvml.Device
	}
	mock.lockDeviceGetDynamicPstatesInfo.RLock()
	calls = mock.calls.DeviceGetDynamicPstatesInfo
	mock.lockDeviceGetDynamicPstatesInfo.RUnlock()
	return calls
}

// DeviceGetEccMode calls DeviceGetEccModeFunc.
func (mock *Interface) DeviceGetEccMode(device nvml.Device) (nvml.EnableState, nvml.EnableState, nvml.Return) {
	if mock.DeviceGetEccModeFunc == nil {
		panic("Interface.DeviceGetEccModeFunc: method is nil but Interface.DeviceGetEccMode was just called")
	}
	callInfo := struct {
		Device nvml.Device
	}{
		Device: device,
	}
	mock.lockDeviceGetEccMode.Lock()
	mock.calls.DeviceGetEccMode = append(mock.calls.DeviceGetEccMode, callInfo)
	mock.lockDeviceGetEccMode.Unlock()
	return mock.DeviceGetEccModeFunc(device)
}

// DeviceGetEccModeCalls gets all the calls that were made to DeviceGetEccMode.
// Check the length with:
//
//	len(mockedInterface.DeviceGetEccModeCalls())
func (mock *Interface) DeviceGetEccModeCalls() []struct {
	Device nvml.Device
} {
	var calls []struct {
		Device nvml.Device
	}
	mock.lockDeviceGetEccMode.RLock()
	calls = mock.calls.DeviceGetEccMode
	mock.lockDeviceGetEccMode.RUnlock()
	return calls
}

// DeviceGetEncoderCapacity calls DeviceGetEncoderCapacityFunc.
func (mock *Interface) DeviceGetEncoderCapacity(device nvml.Device, encoderType nvml.EncoderType) (int, nvml.Return) {
	if mock.DeviceGetEncoderCapacityFunc == nil {
		panic("Interface.DeviceGetEncoderCapacityFunc: method is nil but Interface.DeviceGetEncoderCapacity was just called")
	}
	callInfo := struct {
		Device      nvml.Device
		EncoderType nvml.EncoderType
	}{
		Device:      device,
		EncoderType: encoderType,
	}
	mock.lockDeviceGetEncoderCapacity.Lock()
	mock.calls.DeviceGetEncoderCapacity = append(mock.calls.DeviceGetEncoderCapacity, callInfo)
	mock.lockDeviceGetEncoderCapacity.Unlock()
	return mock.DeviceGetEncoderCapacityFunc(device, encoderType)
}

// DeviceGetEncoderCapacityCalls gets all the calls that were made to DeviceGetEncoderCapacity.
// Check the length with:
//
//	len(mockedInterface.DeviceGetEncoderCapacityCalls())
func (mock *Interface) DeviceGetEncoderCapacityCalls() []struct {
	Device      nvml.Device
	EncoderType nvml.EncoderType
} {
	var calls []struct {
		Device      nvml.Device
		EncoderType nvml.EncoderType
	}
	mock.lockDeviceGetEncoderCapacity.RLock()
	calls = mock.calls.DeviceGetEncoderCapacity
	mock.lockDeviceGetEncoderCapacity.RUnlock()
	return calls
}

// DeviceGetEncoderSessions calls DeviceGetEncoderSessionsFunc.
func (mock *Interface) DeviceGetEncoderSessions(device nvml.Device) ([]nvml.EncoderSessionInfo, nvml.Return) {
	if mock.DeviceGetEncoderSessionsFunc == nil {
		panic("Interface.DeviceGetEncoderSessionsFunc: method is nil but Interface.DeviceGetEncoderSessions was just called")
	}
	callInfo := struct {
		Device nvml.Device
	}{
		Device: device,
	}
	mock.lockDeviceGetEncoderSessions.Lock()
	mock.calls.DeviceGetEncoderSessions = append(mock.calls.DeviceGetEncoderSessions, callInfo)
	mock.lockDeviceGetEncoderSessions.Unlock()
	return mock.DeviceGetEncoderSessionsFunc(device)
}

// DeviceGetEncoderSessionsCalls gets all the calls that were made to DeviceGetEncoderSessions.
// Check the length with:
//
//	len(mockedInterface.DeviceGetEncoderSessionsCalls())
func (mock *Interface) DeviceGetEncoderSessionsCalls() []struct {
	Device nvml.Device
} {
	var calls []struct {
		Device nvml.Device
	}
	mock.lockDeviceGetEncoderSessions.RLock()
	calls = mock.calls.DeviceGetEncoderSessions
	mock.lockDeviceGetEncoderSessions.RUnlock()
	return calls
}

// DeviceGetEncoderStats calls DeviceGetEncoderStatsFunc.
func (mock *Interface) DeviceGetEncoderStats(device nvml.Device) (int, uint32, uint32, nvml.Return) {
	if mock.DeviceGetEncoderStatsFunc == nil {
		panic("Interface.DeviceGetEncoderStatsFunc: method is nil but Interface.DeviceGetEncoderStats was just called")
	}
	callInfo := struct {
		Device nvml.Device
	}{
		Device: device,
	}
	mock.lockDeviceGetEncoderStats.Lock()
	mock.calls.DeviceGetEncoderStats = append(mock.calls.DeviceGetEncoderStats, callInfo)
	mock.lockDeviceGetEncoderStats.Unlock()
	return mock.DeviceGetEncoderStatsFunc(device)
}

// DeviceGetEncoderStatsCalls gets all the calls that were made to DeviceGetEncoderStats.
// Check the length with:
//
//	len(mockedInterface.DeviceGetEncoderStatsCalls())
func (mock *Interface) DeviceGetEncoderStatsCalls() []struct {
	Device nvml.Device
} {
	var calls []struct {
		Device nvml.Device
	}
	mock.lockDeviceGetEncoderStats.RLock()
	calls = mock.calls.DeviceGetEncoderStats
	mock.lockDeviceGetEncoderStats.RUnlock()
	return calls
}

// DeviceGetEncoderUtilization calls DeviceGetEncoderUtilizationFunc.
func (mock *Interface) DeviceGetEncoderUtilization(device nvml.Device) (uint32, uint32, nvml.Return) {
	if mock.DeviceGetEncoderUtilizationFunc == nil {
		panic("Interface.DeviceGetEncoderUtilizationFunc: method is nil but Interface.DeviceGetEncoderUtilization was just called")
	}
	callInfo := struct {
		Device nvml.Device
	}{
		Device: device,
	}
	mock.lockDeviceGetEncoderUtilization.Lock()
	mock.calls.DeviceGetEncoderUtilization = append(mock.calls.DeviceGetEncoderUtilization, callInfo)
	mock.lockDeviceGetEncoderUtilization.Unlock()
	return mock.DeviceGetEncoderUtilizationFunc(device)
}

// DeviceGetEncoderUtilizationCalls gets all the calls that were made to DeviceGetEncoderUtilization.
// Check the length with:
//
//	len(mockedInterface.DeviceGetEncoderUtilizationCalls())
func (mock *Interface) DeviceGetEncoderUtilizationCalls() []struct {
	Device nvml.Device
} {
	var calls []struct {
		Device nvml.Device
	}
	mock.lockDeviceGetEncoderUtilization.RLock()
	calls = mock.calls.DeviceGetEncoderUtilization
	mock.lockDeviceGetEncoderUtilization.RUnlock()
	return calls
}

// DeviceGetEnforcedPowerLimit calls DeviceGetEnforcedPowerLimitFunc.
func (mock *Interface) DeviceGetEnforcedPowerLimit(device nvml.Device) (uint32, nvml.Return) {
	if mock.DeviceGetEnforcedPowerLimitFunc == nil {
		panic("Interface.DeviceGetEnforcedPowerLimitFunc: method is nil but Interface.DeviceGetEnforcedPowerLimit was just called")
	}
	callInfo := struct {
		Device nvml.Device
	}{
		Device: device,
	}
	mock.lockDeviceGetEnforcedPowerLimit.Lock()
	mock.calls.DeviceGetEnforcedPowerLimit = append(mock.calls.DeviceGetEnforcedPowerLimit, callInfo)
	mock.lockDeviceGetEnforcedPowerLimit.Unlock()
	return mock.DeviceGetEnforcedPowerLimitFunc(device)
}

// DeviceGetEnforcedPowerLimitCalls gets all the calls that were made to DeviceGetEnforcedPowerLimit.
// Check the length with:
//
//	len(mockedInterface.DeviceGetEnforcedPowerLimitCalls())
func (mock *Interface) DeviceGetEnforcedPowerLimitCalls() []struct {
	Device nvml.Device
} {
	var calls []struct {
		Device nvml.Device
	}
	mock.lockDeviceGetEnforcedPowerLimit.RLock()
	calls = mock.calls.DeviceGetEnforcedPowerLimit
	mock.lockDeviceGetEnforcedPowerLimit.RUnlock()
	return calls
}

// DeviceGetFBCSessions calls DeviceGetFBCSessionsFunc.
func (mock *Interface) DeviceGetFBCSessions(device nvml.Device) ([]nvml.FBCSessionInfo, nvml.Return) {
	if mock.DeviceGetFBCSessionsFunc == nil {
		panic("Interface.DeviceGetFBCSessionsFunc: method is nil but Interface.DeviceGetFBCSessions was just called")
	}
	callInfo := struct {
		Device nvml.Device
	}{
		Device: device,
	}
	mock.lockDeviceGetFBCSessions.Lock()
	mock.calls.DeviceGetFBCSessions = append(mock.calls.DeviceGetFBCSessions, callInfo)
	mock.lockDeviceGetFBCSessions.Unlock()
	return mock.DeviceGetFBCSessionsFunc(device)
}

// DeviceGetFBCSessionsCalls gets all the calls that were made to DeviceGetFBCSessions.
// Check the length with:
//
//	len(mockedInterface.DeviceGetFBCSessionsCalls())
func (mock *Interface) DeviceGetFBCSessionsCalls() []struct {
	Device nvml.Device
} {
	var calls []struct {
		Device nvml.Device
	}
	mock.lockDeviceGetFBCSessions.RLock()
	calls = mock.calls.DeviceGetFBCSessions
	mock.lockDeviceGetFBCSessions.RUnlock()
	return calls
}

// DeviceGetFBCStats calls DeviceGetFBCStatsFunc.
func (mock *Interface) DeviceGetFBCStats(device nvml.Device) (nvml.FBCStats, nvml.Return) {
	if mock.DeviceGetFBCStatsFunc == nil {
		panic("Interface.DeviceGetFBCStatsFunc: method is nil but Interface.DeviceGetFBCStats was just called")
	}
	callInfo := struct {
		Device nvml.Device
	}{
		Device: device,
	}
	mock.lockDeviceGetFBCStats.Lock()
	mock.calls.DeviceGetFBCStats = append(mock.calls.DeviceGetFBCStats, callInfo)
	mock.lockDeviceGetFBCStats.Unlock()
	return mock.DeviceGetFBCStatsFunc(device)
}

// DeviceGetFBCStatsCalls gets all the calls that were made to DeviceGetFBCStats.
// Check the length with:
//
//	len(mockedInterface.DeviceGetFBCStatsCalls())
func (mock *Interface) DeviceGetFBCStatsCalls() []struct {
	Device nvml.Device
} {
	var calls []struct {
		Device nvml.Device
	}
	mock.lockDeviceGetFBCStats.RLock()
	calls = mock.calls.DeviceGetFBCStats
	mock.lockDeviceGetFBCStats.RUnlock()
	return calls
}

// DeviceGetFanControlPolicy_v2 calls DeviceGetFanControlPolicy_v2Func.
func (mock *Interface) DeviceGetFanControlPolicy_v2(device nvml.Device, n int) (nvml.FanControlPolicy, nvml.Return) {
	if mock.DeviceGetFanControlPolicy_v2Func == nil {
		panic("Interface.DeviceGetFanControlPolicy_v2Func: method is nil but Interface.DeviceGetFanControlPolicy_v2 was just called")
	}
	callInfo := struct {
		Device nvml.Device
		N      int
	}{
		Device: device,
		N:      n,
	}
	mock.lockDeviceGetFanControlPolicy_v2.Lock()
	mock.calls.DeviceGetFanControlPolicy_v2 = append(mock.calls.DeviceGetFanControlPolicy_v2, callInfo)
	mock.lockDeviceGetFanControlPolicy_v2.Unlock()
	return mock.DeviceGetFanControlPolicy_v2Func(device, n)
}

// DeviceGetFanControlPolicy_v2Calls gets all the calls that were made to DeviceGetFanControlPolicy_v2.
// Check the length with:
//
//	len(mockedInterface.DeviceGetFanControlPolicy_v2Calls())
func (mock *Interface) DeviceGetFanControlPolicy_v2Calls() []struct {
	Device nvml.Device
	N      int
} {
	var calls []struct {
		Device nvml.Device
		N      int
	}
	mock.lockDeviceGetFanControlPolicy_v2.RLock()
	calls = mock.calls.DeviceGetFanControlPolicy_v2
	mock.lockDeviceGetFanControlPolicy_v2.RUnlock()
	return calls
}

// DeviceGetFanSpeed calls DeviceGetFanSpeedFunc.
func (mock *Interface) DeviceGetFanSpeed(device nvml.Device) (uint32, nvml.Return) {
	if mock.DeviceGetFanSpeedFunc == nil {
		panic("Interface.DeviceGetFanSpeedFunc: method is nil but Interface.DeviceGetFanSpeed was just called")
	}
	callInfo := struct {
		Device nvml.Device
	}{
		Device: device,
	}
	mock.lockDeviceGetFanSpeed.Lock()
	mock.calls.DeviceGetFanSpeed = append(mock.calls.DeviceGetFanSpeed, callInfo)
	mock.lockDeviceGetFanSpeed.Unlock()
	return mock.DeviceGetFanSpeedFunc(device)
}

// DeviceGetFanSpeedCalls gets all the calls that were made to DeviceGetFanSpeed.
// Check the length with:
//
//	len(mockedInterface.DeviceGetFanSpeedCalls())
func (mock *Interface) DeviceGetFanSpeedCalls() []struct {
	Device nvml.Device
} {
	var calls []struct {
		Device nvml.Device
	}
	mock.lockDeviceGetFanSpeed.RLock()
	calls = mock.calls.DeviceGetFanSpeed
	mock.lockDeviceGetFanSpeed.RUnlock()
	return calls
}

// DeviceGetFanSpeedRPM calls DeviceGetFanSpeedRPMFunc.
func (mock *Interface) DeviceGetFanSpeedRPM(device nvml.Device) (nvml.FanSpeedInfo, nvml.Return) {
	if mock.DeviceGetFanSpeedRPMFunc == nil {
		panic("Interface.DeviceGetFanSpeedRPMFunc: method is nil but Interface.DeviceGetFanSpeedRPM was just called")
	}
	callInfo := struct {
		Device nvml.Device
	}{
		Device: device,
	}
	mock.lockDeviceGetFanSpeedRPM.Lock()
	mock.calls.DeviceGetFanSpeedRPM = append(mock.calls.DeviceGetFanSpeedRPM, callInfo)
	mock.lockDeviceGetFanSpeedRPM.Unlock()
	return mock.DeviceGetFanSpeedRPMFunc(device)
}

// DeviceGetFanSpeedRPMCalls gets all the calls that were made to DeviceGetFanSpeedRPM.
// Check the length with:
//
//	len(mockedInterface.DeviceGetFanSpeedRPMCalls())
func (mock *Interface) DeviceGetFanSpeedRPMCalls() []struct {
	Device nvml.Device
} {
	var calls []struct {
		Device nvml.Device
	}
	mock.lockDeviceGetFanSpeedRPM.RLock()
	calls = mock.calls.DeviceGetFanSpeedRPM
	mock.lockDeviceGetFanSpeedRPM.RUnlock()
	return calls
}

// DeviceGetFanSpeed_v2 calls DeviceGetFanSpeed_v2Func.
func (mock *Interface) DeviceGetFanSpeed_v2(device nvml.Device, n int) (uint32, nvml.Return) {
	if mock.DeviceGetFanSpeed_v2Func == nil {
		panic("Interface.DeviceGetFanSpeed_v2Func: method is nil but Interface.DeviceGetFanSpeed_v2 was just called")
	}
	callInfo := struct {
		Device nvml.Device
		N      int
	}{
		Device: device,
		N:      n,
	}
	mock.lockDeviceGetFanSpeed_v2.Lock()
	mock.calls.DeviceGetFanSpeed_v2 = append(mock.calls.DeviceGetFanSpeed_v2, callInfo)
	mock.lockDeviceGetFanSpeed_v2.Unlock()
	return mock.DeviceGetFanSpeed_v2Func(device, n)
}

// DeviceGetFanSpeed_v2Calls gets all the calls that were made to DeviceGetFanSpeed_v2.
// Check the length with:
//
//	len(mockedInterface.DeviceGetFanSpeed_v2Calls())
func (mock *Interface) DeviceGetFanSpeed_v2Calls() []struct {
	Device nvml.Device
	N      int
} {
	var calls []struct {
		Device nvml.Device
		N      int
	}
	mock.lockDeviceGetFanSpeed_v2.RLock()
	calls = mock.calls.DeviceGetFanSpeed_v2
	mock.lockDeviceGetFanSpeed_v2.RUnlock()
	return calls
}

// DeviceGetFieldValues calls DeviceGetFieldValuesFunc.
func (mock *Interface) DeviceGetFieldValues(device nvml.Device, fieldValues []nvml.FieldValue) nvml.Return {
	if mock.DeviceGetFieldValuesFunc == nil {
		panic("Interface.DeviceGetFieldValuesFunc: method is nil but Interface.DeviceGetFieldValues was just called")
	}
	callInfo := struct {
		Device      nvml.Device
		FieldValues []nvml.FieldValue
	}{
		Device:      device,
		FieldValues: fieldValues,
	}
	mock.lockDeviceGetFieldValues.Lock()
	mock.calls.DeviceGetFieldValues = append(mock.calls.DeviceGetFieldValues, callInfo)
	mock.lockDeviceGetFieldValues.Unlock()
	return mock.DeviceGetFieldValuesFunc(device, fieldValues)
}

// DeviceGetFieldValuesCalls gets all the calls that were made to DeviceGetFieldValues.
// Check the length with:
//
//	len(mockedInterface.DeviceGetFieldValuesCalls())
func (mock *Interface) DeviceGetFieldValuesCalls() []struct {
	Device      nvml.Device
	FieldValues []nvml.FieldValue
} {
	var calls []struct {
		Device      nvml.Device
		FieldValues []nvml.FieldValue
	}
	mock.lockDeviceGetFieldValues.RLock()
	calls = mock.calls.DeviceGetFieldValues
	mock.lockDeviceGetFieldValues.RUnlock()
	return calls
}

// DeviceGetGpcClkMinMaxVfOffset calls DeviceGetGpcClkMinMaxVfOffsetFunc.
func (mock *Interface) DeviceGetGpcClkMinMaxVfOffset(device nvml.Device) (int, int, nvml.Return) {
	if mock.DeviceGetGpcClkMinMaxVfOffsetFunc == nil {
		panic("Interface.DeviceGetGpcClkMinMaxVfOffsetFunc: method is nil but Interface.DeviceGetGpcClkMinMaxVfOffset was just called")
	}
	callInfo := struct {
		Device nvml.Device
	}{
		Device: device,
	}
	mock.lockDeviceGetGpcClkMinMaxVfOffset.Lock()
	mock.calls.DeviceGetGpcClkMinMaxVfOffset = append(mock.calls.DeviceGetGpcClkMinMaxVfOffset, callInfo)
	mock.lockDeviceGetGpcClkMinMaxVfOffset.Unlock()
	return mock.DeviceGetGpcClkMinMaxVfOffsetFunc(device)
}

// DeviceGetGpcClkMinMaxVfOffsetCalls gets all the calls that were made to DeviceGetGpcClkMinMaxVfOffset.
// Check the length with:
//
//	len(mockedInterface.DeviceGetGpcClkMinMaxVfOffsetCalls())
func (mock *Interface) DeviceGetGpcClkMinMaxVfOffsetCalls() []struct {
	Device nvml.Device
} {
	var calls []struct {
		Device nvml.Device
	}
	mock.lockDeviceGetGpcClkMinMaxVfOffset.RLock()
	calls = mock.calls.DeviceGetGpcClkMinMaxVfOffset
	mock.lockDeviceGetGpcClkMinMaxVfOffset.RUnlock()
	return calls
}

// DeviceGetGpcClkVfOffset calls DeviceGetGpcClkVfOffsetFunc.
func (mock *Interface) DeviceGetGpcClkVfOffset(device nvml.Device) (int, nvml.Return) {
	if mock.DeviceGetGpcClkVfOffsetFunc == nil {
		panic("Interface.DeviceGetGpcClkVfOffsetFunc: method is nil but Interface.DeviceGetGpcClkVfOffset was just called")
	}
	callInfo := struct {
		Device nvml.Device
	}{
		Device: device,
	}
	mock.lockDeviceGetGpcClkVfOffset.Lock()
	mock.calls.DeviceGetGpcClkVfOffset = append(mock.calls.DeviceGetGpcClkVfOffset, callInfo)
	mock.lockDeviceGetGpcClkVfOffset.Unlock()
	return mock.DeviceGetGpcClkVfOffsetFunc(device)
}

// DeviceGetGpcClkVfOffsetCalls gets all the calls that were made to DeviceGetGpcClkVfOffset.
// Check the length with:
//
//	len(mockedInterface.DeviceGetGpcClkVfOffsetCalls())
func (mock *Interface) DeviceGetGpcClkVfOffsetCalls() []struct {
	Device nvml.Device
} {
	var calls []struct {
		Device nvml.Device
	}
	mock.lockDeviceGetGpcClkVfOffset.RLock()
	calls = mock.calls.DeviceGetGpcClkVfOffset
	mock.lockDeviceGetGpcClkVfOffset.RUnlock()
	return calls
}

// DeviceGetGpuFabricInfo calls DeviceGetGpuFabricInfoFunc.
func (mock *Interface) DeviceGetGpuFabricInfo(device nvml.Device) (nvml.GpuFabricInfo, nvml.Return) {
	if mock.DeviceGetGpuFabricInfoFunc == nil {
		panic("Interface.DeviceGetGpuFabricInfoFunc: method is nil but Interface.DeviceGetGpuFabricInfo was just called")
	}
	callInfo := struct {
		Device nvml.Device
	}{
		Device: device,
	}
	mock.lockDeviceGetGpuFabricInfo.Lock()
	mock.calls.DeviceGetGpuFabricInfo = append(mock.calls.DeviceGetGpuFabricInfo, callInfo)
	mock.lockDeviceGetGpuFabricInfo.Unlock()
	return mock.DeviceGetGpuFabricInfoFunc(device)
}

// DeviceGetGpuFabricInfoCalls gets all the calls that were made to DeviceGetGpuFabricInfo.
// Check the length with:
//
//	len(mockedInterface.DeviceGetGpuFabricInfoCalls())
func (mock *Interface) DeviceGetGpuFabricInfoCalls() []struct {
	Device nvml.Device
} {
	var calls []struct {
		Device nvml.Device
	}
	mock.lockDeviceGetGpuFabricInfo.RLock()
	calls = mock.calls.DeviceGetGpuFabricInfo
	mock.lockDeviceGetGpuFabricInfo.RUnlock()
	return calls
}

// DeviceGetGpuFabricInfoV calls DeviceGetGpuFabricInfoVFunc.
func (mock *Interface) DeviceGetGpuFabricInfoV(device nvml.Device) nvml.GpuFabricInfoHandler {
	if mock.DeviceGetGpuFabricInfoVFunc == nil {
		panic("Interface.DeviceGetGpuFabricInfoVFunc: method is nil but Interface.DeviceGetGpuFabricInfoV was just called")
	}
	callInfo := struct {
		Device nvml.Device
	}{
		Device: device,
	}
	mock.lockDeviceGetGpuFabricInfoV.Lock()
	mock.calls.DeviceGetGpuFabricInfoV = append(mock.calls.DeviceGetGpuFabricInfoV, callInfo)
	mock.lockDeviceGetGpuFabricInfoV.Unlock()
	return mock.DeviceGetGpuFabricInfoVFunc(device)
}

// DeviceGetGpuFabricInfoVCalls gets all the calls that were made to DeviceGetGpuFabricInfoV.
// Check the length with:
//
//	len(mockedInterface.DeviceGetGpuFabricInfoVCalls())
func (mock *Interface) DeviceGetGpuFabricInfoVCalls() []struct {
	Device nvml.Device
} {
	var calls []struct {
		Device nvml.Device
	}
	mock.lockDeviceGetGpuFabricInfoV.RLock()
	calls = mock.calls.DeviceGetGpuFabricInfoV
	mock.lockDeviceGetGpuFabricInfoV.RUnlock()
	return calls
}

// DeviceGetGpuInstanceById calls DeviceGetGpuInstanceByIdFunc.
func (mock *Interface) DeviceGetGpuInstanceById(device nvml.Device, n int) (nvml.GpuInstance, nvml.Return) {
	if mock.DeviceGetGpuInstanceByIdFunc == nil {
		panic("Interface.DeviceGetGpuInstanceByIdFunc: method is nil but Interface.DeviceGetGpuInstanceById was just called")
	}
	callInfo := struct {
		Device nvml.Device
		N      int
	}{
		Device: device,
		N:      n,
	}
	mock.lockDeviceGetGpuInstanceById.Lock()
	mock.calls.DeviceGetGpuInstanceById = append(mock.calls.DeviceGetGpuInstanceById, callInfo)
	mock.lockDeviceGetGpuInstanceById.Unlock()
	return mock.DeviceGetGpuInstanceByIdFunc(device, n)
}

// DeviceGetGpuInstanceByIdCalls gets all the calls that were made to DeviceGetGpuInstanceById.
// Check the length with:
//
//	len(mockedInterface.DeviceGetGpuInstanceByIdCalls())
func (mock *Interface) DeviceGetGpuInstanceByIdCalls() []struct {
	Device nvml.Device
	N      int
} {
	var calls []struct {
		Device nvml.Device
		N      int
	}
	mock.lockDeviceGetGpuInstanceById.RLock()
	calls = mock.calls.DeviceGetGpuInstanceById
	mock.lockDeviceGetGpuInstanceById.RUnlock()
	return calls
}

// DeviceGetGpuInstanceId calls DeviceGetGpuInstanceIdFunc.
func (mock *Interface) DeviceGetGpuInstanceId(device nvml.Device) (int, nvml.Return) {
	if mock.DeviceGetGpuInstanceIdFunc == nil {
		panic("Interface.DeviceGetGpuInstanceIdFunc: method is nil but Interface.DeviceGetGpuInstanceId was just called")
	}
	callInfo := struct {
		Device nvml.Device
	}{
		Device: device,
	}
	mock.lockDeviceGetGpuInstanceId.Lock()
	mock.calls.DeviceGetGpuInstanceId = append(mock.calls.DeviceGetGpuInstanceId, callInfo)
	mock.lockDeviceGetGpuInstanceId.Unlock()
	return mock.DeviceGetGpuInstanceIdFunc(device)
}

// DeviceGetGpuInstanceIdCalls gets all the calls that were made to DeviceGetGpuInstanceId.
// Check the length with:
//
//	len(mockedInterface.DeviceGetGpuInstanceIdCalls())
func (mock *Interface) DeviceGetGpuInstanceIdCalls() []struct {
	Device nvml.Device
} {
	var calls []struct {
		Device nvml.Device
	}
	mock.lockDeviceGetGpuInstanceId.RLock()
	calls = mock.calls.DeviceGetGpuInstanceId
	mock.lockDeviceGetGpuInstanceId.RUnlock()
	return calls
}

// DeviceGetGpuInstancePossiblePlacements calls DeviceGetGpuInstancePossiblePlacementsFunc.
func (mock *Interface) DeviceGetGpuInstancePossiblePlacements(device nvml.Device, gpuInstanceProfileInfo *nvml.GpuInstanceProfileInfo) ([]nvml.GpuInstancePlacement, nvml.Return) {
	if mock.DeviceGetGpuInstancePossiblePlacementsFunc == nil {
		panic("Interface.DeviceGetGpuInstancePossiblePlacementsFunc: method is nil but Interface.DeviceGetGpuInstancePossiblePlacements was just called")
	}
	callInfo := struct {
		Device                 nvml.Device
		GpuInstanceProfileInfo *nvml.GpuInstanceProfileInfo
	}{
		Device:                 device,
		GpuInstanceProfileInfo: gpuInstanceProfileInfo,
	}
	mock.lockDeviceGetGpuInstancePossiblePlacements.Lock()
	mock.calls.DeviceGetGpuInstancePossiblePlacements = append(mock.calls.DeviceGetGpuInstancePossiblePlacements, callInfo)
	mock.lockDeviceGetGpuInstancePossiblePlacements.Unlock()
	return mock.DeviceGetGpuInstancePossiblePlacementsFunc(device, gpuInstanceProfileInfo)
}

// DeviceGetGpuInstancePossiblePlacementsCalls gets all the calls that were made to DeviceGetGpuInstancePossiblePlacements.
// Check the length with:
//
//	len(mockedInterface.DeviceGetGpuInstancePossiblePlacementsCalls())
func (mock *Interface) DeviceGetGpuInstancePossiblePlacementsCalls() []struct {
	Device                 nvml.Device
	GpuInstanceProfileInfo *nvml.GpuInstanceProfileInfo
} {
	var calls []struct {
		Device                 nvml.Device
		GpuInstanceProfileInfo *nvml.GpuInstanceProfileInfo
	}
	mock.lockDeviceGetGpuInstancePossiblePlacements.RLock()
	calls = mock.calls.DeviceGetGpuInstancePossiblePlacements
	mock.lockDeviceGetGpuInstancePossiblePlacements.RUnlock()
	return calls
}

// DeviceGetGpuInstanceProfileInfo calls DeviceGetGpuInstanceProfileInfoFunc.
func (mock *Interface) DeviceGetGpuInstanceProfileInfo(device nvml.Device, n int) (nvml.GpuInstanceProfileInfo, nvml.Return) {
	if mock.DeviceGetGpuInstanceProfileInfoFunc == nil {
		panic("Interface.DeviceGetGpuInstanceProfileInfoFunc: method is nil but Interface.DeviceGetGpuInstanceProfileInfo was just called")
	}
	callInfo := struct {
		Device nvml.Device
		N      int
	}{
		Device: device,
		N:      n,
	}
	mock.lockDeviceGetGpuInstanceProfileInfo.Lock()
	mock.calls.DeviceGetGpuInstanceProfileInfo = append(mock.calls.DeviceGetGpuInstanceProfileInfo, callInfo)
	mock.lockDeviceGetGpuInstanceProfileInfo.Unlock()
	return mock.DeviceGetGpuInstanceProfileInfoFunc(device, n)
}

// DeviceGetGpuInstanceProfileInfoCalls gets all the calls that were made to DeviceGetGpuInstanceProfileInfo.
// Check the length with:
//
//	len(mockedInterface.DeviceGetGpuInstanceProfileInfoCalls())
func (mock *Interface) DeviceGetGpuInstanceProfileInfoCalls() []struct {
	Device nvml.Device
	N      int
} {
	var calls []struct {
		Device nvml.Device
		N      int
	}
	mock.lockDeviceGetGpuInstanceProfileInfo.RLock()
	calls = mock.calls.DeviceGetGpuInstanceProfileInfo
	mock.lockDeviceGetGpuInstanceProfileInfo.RUnlock()
	return calls
}

// DeviceGetGpuInstanceProfileInfoByIdV calls DeviceGetGpuInstanceProfileInfoByIdVFunc.
func (mock *Interface) DeviceGetGpuInstanceProfileInfoByIdV(device nvml.Device, n int) nvml.GpuInstanceProfileInfoByIdHandler {
	if mock.DeviceGetGpuInstanceProfileInfoByIdVFunc == nil {
		panic("Interface.DeviceGetGpuInstanceProfileInfoByIdVFunc: method is nil but Interface.DeviceGetGpuInstanceProfileInfoByIdV was just called")
	}
	callInfo := struct {
		Device nvml.Device
		N      int
	}{
		Device: device,
		N:      n,
	}
	mock.lockDeviceGetGpuInstanceProfileInfoByIdV.Lock()
	mock.calls.DeviceGetGpuInstanceProfileInfoByIdV = append(mock.calls.DeviceGetGpuInstanceProfileInfoByIdV, callInfo)
	mock.lockDeviceGetGpuInstanceProfileInfoByIdV.Unlock()
	return mock.DeviceGetGpuInstanceProfileInfoByIdVFunc(device, n)
}

// DeviceGetGpuInstanceProfileInfoByIdVCalls gets all the calls that were made to DeviceGetGpuInstanceProfileInfoByIdV.
// Check the length with:
//
//	len(mockedInterface.DeviceGetGpuInstanceProfileInfoByIdVCalls())
func (mock *Interface) DeviceGetGpuInstanceProfileInfoByIdVCalls() []struct {
	Device nvml.Device
	N      int
} {
	var calls []struct {
		Device nvml.Device
		N      int
	}
	mock.lockDeviceGetGpuInstanceProfileInfoByIdV.RLock()
	calls = mock.calls.DeviceGetGpuInstanceProfileInfoByIdV
	mock.lockDeviceGetGpuInstanceProfileInfoByIdV.RUnlock()
	return calls
}

// DeviceGetGpuInstanceProfileInfoV calls DeviceGetGpuInstanceProfileInfoVFunc.
func (mock *Interface) DeviceGetGpuInstanceProfileInfoV(device nvml.Device, n int) nvml.GpuInstanceProfileInfoHandler {
	if mock.DeviceGetGpuInstanceProfileInfoVFunc == nil {
		panic("Interface.DeviceGetGpuInstanceProfileInfoVFunc: method is nil but Interface.DeviceGetGpuInstanceProfileInfoV was just called")
	}
	callInfo := struct {
		Device nvml.Device
		N      int
	}{
		Device: device,
		N:      n,
	}
	mock.lockDeviceGetGpuInstanceProfileInfoV.Lock()
	mock.calls.DeviceGetGpuInstanceProfileInfoV = append(mock.calls.DeviceGetGpuInstanceProfileInfoV, callInfo)
	mock.lockDeviceGetGpuInstanceProfileInfoV.Unlock()
	return mock.DeviceGetGpuInstanceProfileInfoVFunc(device, n)
}

// DeviceGetGpuInstanceProfileInfoVCalls gets all the calls that were made to DeviceGetGpuInstanceProfileInfoV.
// Check the length with:
//
//	len(mockedInterface.DeviceGetGpuInstanceProfileInfoVCalls())
func (mock *Interface) DeviceGetGpuInstanceProfileInfoVCalls() []struct {
	Device nvml.Device
	N      int
} {
	var calls []struct {
		Device nvml.Device
		N      int
	}
	mock.lockDeviceGetGpuInstanceProfileInfoV.RLock()
	calls = mock.calls.DeviceGetGpuInstanceProfileInfoV
	mock.lockDeviceGetGpuInstanceProfileInfoV.RUnlock()
	return calls
}

// DeviceGetGpuInstanceRemainingCapacity calls DeviceGetGpuInstanceRemainingCapacityFunc.
func (mock *Interface) DeviceGetGpuInstanceRemainingCapacity(device nvml.Device, gpuInstanceProfileInfo *nvml.GpuInstanceProfileInfo) (int, nvml.Return) {
	if mock.DeviceGetGpuInstanceRemainingCapacityFunc == nil {
		panic("Interface.DeviceGetGpuInstanceRemainingCapacityFunc: method is nil but Interface.DeviceGetGpuInstanceRemainingCapacity was just called")
	}
	callInfo := struct {
		Device                 nvml.Device
		GpuInstanceProfileInfo *nvml.GpuInstanceProfileInfo
	}{
		Device:                 device,
		GpuInstanceProfileInfo: gpuInstanceProfileInfo,
	}
	mock.lockDeviceGetGpuInstanceRemainingCapacity.Lock()
	mock.calls.DeviceGetGpuInstanceRemainingCapacity = append(mock.calls.DeviceGetGpuInstanceRemainingCapacity, callInfo)
	mock.lockDeviceGetGpuInstanceRemainingCapacity.Unlock()
	return mock.DeviceGetGpuInstanceRemainingCapacityFunc(device, gpuInstanceProfileInfo)
}

// DeviceGetGpuInstanceRemainingCapacityCalls gets all the calls that were made to DeviceGetGpuInstanceRemainingCapacity.
// Check the length with:
//
//	len(mockedInterface.DeviceGetGpuInstanceRemainingCapacityCalls())
func (mock *Interface) DeviceGetGpuInstanceRemainingCapacityCalls() []struct {
	Device                 nvml.Device
	GpuInstanceProfileInfo *nvml.GpuInstanceProfileInfo
} {
	var calls []struct {
		Device                 nvml.Device
		GpuInstanceProfileInfo *nvml.GpuInstanceProfileInfo
	}
	mock.lockDeviceGetGpuInstanceRemainingCapacity.RLock()
	calls = mock.calls.DeviceGetGpuInstanceRemainingCapacity
	mock.lockDeviceGetGpuInstanceRemainingCapacity.RUnlock()
	return calls
}

// DeviceGetGpuInstances calls DeviceGetGpuInstancesFunc.
func (mock *Interface) DeviceGetGpuInstances(device nvml.Device, gpuInstanceProfileInfo *nvml.GpuInstanceProfileInfo) ([]nvml.GpuInstance, nvml.Return) {
	if mock.DeviceGetGpuInstancesFunc == nil {
		panic("Interface.DeviceGetGpuInstancesFunc: method is nil but Interface.DeviceGetGpuInstances was just called")
	}
	callInfo := struct {
		Device                 nvml.Device
		GpuInstanceProfileInfo *nvml.GpuInstanceProfileInfo
	}{
		Device:                 device,
		GpuInstanceProfileInfo: gpuInstanceProfileInfo,
	}
	mock.lockDeviceGetGpuInstances.Lock()
	mock.calls.DeviceGetGpuInstances = append(mock.calls.DeviceGetGpuInstances, callInfo)
	mock.lockDeviceGetGpuInstances.Unlock()
	return mock.DeviceGetGpuInstancesFunc(device, gpuInstanceProfileInfo)
}

// DeviceGetGpuInstancesCalls gets all the calls that were made to DeviceGetGpuInstances.
// Check the length with:
//
//	len(mockedInterface.DeviceGetGpuInstancesCalls())
func (mock *Interface) DeviceGetGpuInstancesCalls() []struct {
	Device                 nvml.Device
	GpuInstanceProfileInfo *nvml.GpuInstanceProfileInfo
} {
	var calls []struct {
		Device                 nvml.Device
		GpuInstanceProfileInfo *nvml.GpuInstanceProfileInfo
	}
	mock.lockDeviceGetGpuInstances.RLock()
	calls = mock.calls.DeviceGetGpuInstances
	mock.lockDeviceGetGpuInstances.RUnlock()
	return calls
}

// DeviceGetGpuMaxPcieLinkGeneration calls DeviceGetGpuMaxPcieLinkGenerationFunc.
func (mock *Interface) DeviceGetGpuMaxPcieLinkGeneration(device nvml.Device) (int, nvml.Return) {
	if mock.DeviceGetGpuMaxPcieLinkGenerationFunc == nil {
		panic("Interface.DeviceGetGpuMaxPcieLinkGenerationFunc: method is nil but Interface.DeviceGetGpuMaxPcieLinkGeneration was just called")
	}
	callInfo := struct {
		Device nvml.Device
	}{
		Device: device,
	}
	mock.lockDeviceGetGpuMaxPcieLinkGeneration.Lock()
	mock.calls.DeviceGetGpuMaxPcieLinkGeneration = append(mock.calls.DeviceGetGpuMaxPcieLinkGeneration, callInfo)
	mock.lockDeviceGetGpuMaxPcieLinkGeneration.Unlock()
	return mock.DeviceGetGpuMaxPcieLinkGenerationFunc(device)
}

// DeviceGetGpuMaxPcieLinkGenerationCalls gets all the calls that were made to DeviceGetGpuMaxPcieLinkGeneration.
// Check the length with:
//
//	len(mockedInterface.DeviceGetGpuMaxPcieLinkGenerationCalls())
func (mock *Interface) DeviceGetGpuMaxPcieLinkGenerationCalls() []struct {
	Device nvml.Device
} {
	var calls []struct {
		Device nvml.Device
	}
	mock.lockDeviceGetGpuMaxPcieLinkGeneration.RLock()
	calls = mock.calls.DeviceGetGpuMaxPcieLinkGeneration
	mock.lockDeviceGetGpuMaxPcieLinkGeneration.RUnlock()
	return calls
}

// DeviceGetGpuOperationMode calls DeviceGetGpuOperationModeFunc.
func (mock *Interface) DeviceGetGpuOperationMode(device nvml.Device) (nvml.GpuOperationMode, nvml.GpuOperationMode, nvml.Return) {
	if mock.DeviceGetGpuOperationModeFunc == nil {
		panic("Interface.DeviceGetGpuOperationModeFunc: method is nil but Interface.DeviceGetGpuOperationMode was just called")
	}
	callInfo := struct {
		Device nvml.Device
	}{
		Device: device,
	}
	mock.lockDeviceGetGpuOperationMode.Lock()
	mock.calls.DeviceGetGpuOperationMode = append(mock.calls.DeviceGetGpuOperationMode, callInfo)
	mock.lockDeviceGetGpuOperationMode.Unlock()
	return mock.DeviceGetGpuOperationModeFunc(device)
}

// DeviceGetGpuOperationModeCalls gets all the calls that were made to DeviceGetGpuOperationMode.
// Check the length with:
//
//	len(mockedInterface.DeviceGetGpuOperationModeCalls())
func (mock *Interface) DeviceGetGpuOperationModeCalls() []struct {
	Device nvml.Device
} {
	var calls []struct {
		Device nvml.Device
	}
	mock.lockDeviceGetGpuOperationMode.RLock()
	calls = mock.calls.DeviceGetGpuOperationMode
	mock.lockDeviceGetGpuOperationMode.RUnlock()
	return calls
}

// DeviceGetGraphicsRunningProcesses calls DeviceGetGraphicsRunningProcessesFunc.
func (mock *Interface) DeviceGetGraphicsRunningProcesses(device nvml.Device) ([]nvml.ProcessInfo, nvml.Return) {
	if mock.DeviceGetGraphicsRunningProcessesFunc == nil {
		panic("Interface.DeviceGetGraphicsRunningProcessesFunc: method is nil but Interface.DeviceGetGraphicsRunningProcesses was just called")
	}
	callInfo := struct {
		Device nvml.Device
	}{
		Device: device,
	}
	mock.lockDeviceGetGraphicsRunningProcesses.Lock()
	mock.calls.DeviceGetGraphicsRunningProcesses = append(mock.calls.DeviceGetGraphicsRunningProcesses, callInfo)
	mock.lockDeviceGetGraphicsRunningProcesses.Unlock()
	return mock.DeviceGetGraphicsRunningProcessesFunc(device)
}

// DeviceGetGraphicsRunningProcessesCalls gets all the calls that were made to DeviceGetGraphicsRunningProcesses.
// Check the length with:
//
//	len(mockedInterface.DeviceGetGraphicsRunningProcessesCalls())
func (mock *Interface) DeviceGetGraphicsRunningProcessesCalls() []struct {
	Device nvml.Device
} {
	var calls []struct {
		Device nvml.Device
	}
	mock.lockDeviceGetGraphicsRunningProcesses.RLock()
	calls = mock.calls.DeviceGetGraphicsRunningProcesses
	mock.lockDeviceGetGraphicsRunningProcesses.RUnlock()
	return calls
}

// DeviceGetGridLicensableFeatures calls DeviceGetGridLicensableFeaturesFunc.
func (mock *Interface) DeviceGetGridLicensableFeatures(device nvml.Device) (nvml.GridLicensableFeatures, nvml.Return) {
	if mock.DeviceGetGridLicensableFeaturesFunc == nil {
		panic("Interface.DeviceGetGridLicensableFeaturesFunc: method is nil but Interface.DeviceGetGridLicensableFeatures was just called")
	}
	callInfo := struct {
		Device nvml.Device
	}{
		Device: device,
	}
	mock.lockDeviceGetGridLicensableFeatures.Lock()
	mock.calls.DeviceGetGridLicensableFeatures = append(mock.calls.DeviceGetGridLicensableFeatures, callInfo)
	mock.lockDeviceGetGridLicensableFeatures.Unlock()
	return mock.DeviceGetGridLicensableFeaturesFunc(device)
}

// DeviceGetGridLicensableFeaturesCalls gets all the calls that were made to DeviceGetGridLicensableFeatures.
// Check the length with:
//
//	len(mockedInterface.DeviceGetGridLicensableFeaturesCalls())
func (mock *Interface) DeviceGetGridLicensableFeaturesCalls() []struct {
	Device nvml.Device
} {
	var calls []struct {
		Device nvml.Device
	}
	mock.lockDeviceGetGridLicensableFeatures.RLock()
	calls = mock.calls.DeviceGetGridLicensableFeatures
	mock.lockDeviceGetGridLicensableFeatures.RUnlock()
	return calls
}

// DeviceGetGspFirmwareMode calls DeviceGetGspFirmwareModeFunc.
func (mock *Interface) DeviceGetGspFirmwareMode(device nvml.Device) (bool, bool, nvml.Return) {
	if mock.DeviceGetGspFirmwareModeFunc == nil {
		panic("Interface.DeviceGetGspFirmwareModeFunc: method is nil but Interface.DeviceGetGspFirmwareMode was just called")
	}
	callInfo := struct {
		Device nvml.Device
	}{
		Device: device,
	}
	mock.lockDeviceGetGspFirmwareMode.Lock()
	mock.calls.DeviceGetGspFirmwareMode = append(mock.calls.DeviceGetGspFirmwareMode, callInfo)
	mock.lockDeviceGetGspFirmwareMode.Unlock()
	return mock.DeviceGetGspFirmwareModeFunc(device)
}

// DeviceGetGspFirmwareModeCalls gets all the calls that were made to DeviceGetGspFirmwareMode.
// Check the length with:
//
//	len(mockedInterface.DeviceGetGspFirmwareModeCalls())
func (mock *Interface) DeviceGetGspFirmwareModeCalls() []struct {
	Device nvml.Device
} {
	var calls []struct {
		Device nvml.Device
	}
	mock.lockDeviceGetGspFirmwareMode.RLock()
	calls = mock.calls.DeviceGetGspFirmwareMode
	mock.lockDeviceGetGspFirmwareMode.RUnlock()
	return calls
}

// DeviceGetGspFirmwareVersion calls DeviceGetGspFirmwareVersionFunc.
func (mock *Interface) DeviceGetGspFirmwareVersion(device nvml.Device) (string, nvml.Return) {
	if mock.DeviceGetGspFirmwareVersionFunc == nil {
		panic("Interface.DeviceGetGspFirmwareVersionFunc: method is nil but Interface.DeviceGetGspFirmwareVersion was just called")
	}
	callInfo := struct {
		Device nvml.Device
	}{
		Device: device,
	}
	mock.lockDeviceGetGspFirmwareVersion.Lock()
	mock.calls.DeviceGetGspFirmwareVersion = append(mock.calls.DeviceGetGspFirmwareVersion, callInfo)
	mock.lockDeviceGetGspFirmwareVersion.Unlock()
	return mock.DeviceGetGspFirmwareVersionFunc(device)
}

// DeviceGetGspFirmwareVersionCalls gets all the calls that were made to DeviceGetGspFirmwareVersion.
// Check the length with:
//
//	len(mockedInterface.DeviceGetGspFirmwareVersionCalls())
func (mock *Interface) DeviceGetGspFirmwareVersionCalls() []struct {
	Device nvml.Device
} {
	var calls []struct {
		Device nvml.Device
	}
	mock.lockDeviceGetGspFirmwareVersion.RLock()
	calls = mock.calls.DeviceGetGspFirmwareVersion
	mock.lockDeviceGetGspFirmwareVersion.RUnlock()
	return calls
}

// DeviceGetHandleByIndex calls DeviceGetHandleByIndexFunc.
func (mock *Interface) DeviceGetHandleByIndex(n int) (nvml.Device, nvml.Return) {
	if mock.DeviceGetHandleByIndexFunc == nil {
		panic("Interface.DeviceGetHandleByIndexFunc: method is nil but Interface.DeviceGetHandleByIndex was just called")
	}
	callInfo := struct {
		N int
	}{
		N: n,
	}
	mock.lockDeviceGetHandleByIndex.Lock()
	mock.calls.DeviceGetHandleByIndex = append(mock.calls.DeviceGetHandleByIndex, callInfo)
	mock.lockDeviceGetHandleByIndex.Unlock()
	return mock.DeviceGetHandleByIndexFunc(n)
}

// DeviceGetHandleByIndexCalls gets all the calls that were made to DeviceGetHandleByIndex.
// Check the length with:
//
//	len(mockedInterface.DeviceGetHandleByIndexCalls())
func (mock *Interface) DeviceGetHandleByIndexCalls() []struct {
	N int
} {
	var calls []struct {
		N int
	}
	mock.lockDeviceGetHandleByIndex.RLock()
	calls = mock.calls.DeviceGetHandleByIndex
	mock.lockDeviceGetHandleByIndex.RUnlock()
	return calls
}

// DeviceGetHandleByPciBusId calls DeviceGetHandleByPciBusIdFunc.
func (mock *Interface) DeviceGetHandleByPciBusId(s string) (nvml.Device, nvml.Return) {
	if mock.DeviceGetHandleByPciBusIdFunc == nil {
		panic("Interface.DeviceGetHandleByPciBusIdFunc: method is nil but Interface.DeviceGetHandleByPciBusId was just called")
	}
	callInfo := struct {
		S string
	}{
		S: s,
	}
	mock.lockDeviceGetHandleByPciBusId.Lock()
	mock.calls.DeviceGetHandleByPciBusId = append(mock.calls.DeviceGetHandleByPciBusId, callInfo)
	mock.lockDeviceGetHandleByPciBusId.Unlock()
	return mock.DeviceGetHandleByPciBusIdFunc(s)
}

// DeviceGetHandleByPciBusIdCalls gets all the calls that were made to DeviceGetHandleByPciBusId.
// Check the length with:
//
//	len(mockedInterface.DeviceGetHandleByPciBusIdCalls())
func (mock *Interface) DeviceGetHandleByPciBusIdCalls() []struct {
	S string
} {
	var calls []struct {
		S string
	}
	mock.lockDeviceGetHandleByPciBusId.RLock()
	calls = mock.calls.DeviceGetHandleByPciBusId
	mock.lockDeviceGetHandleByPciBusId.RUnlock()
	return calls
}

// DeviceGetHandleBySerial calls DeviceGetHandleBySerialFunc.
func (mock *Interface) DeviceGetHandleBySerial(s string) (nvml.Device, nvml.Return) {
	if mock.DeviceGetHandleBySerialFunc == nil {
		panic("Interface.DeviceGetHandleBySerialFunc: method is nil but Interface.DeviceGetHandleBySerial was just called")
	}
	callInfo := struct {
		S string
	}{
		S: s,
	}
	mock.lockDeviceGetHandleBySerial.Lock()
	mock.calls.DeviceGetHandleBySerial = append(mock.calls.DeviceGetHandleBySerial, callInfo)
	mock.lockDeviceGetHandleBySerial.Unlock()
	return mock.DeviceGetHandleBySerialFunc(s)
}

// DeviceGetHandleBySerialCalls gets all the calls that were made to DeviceGetHandleBySerial.
// Check the length with:
//
//	len(mockedInterface.DeviceGetHandleBySerialCalls())
func (mock *Interface) DeviceGetHandleBySerialCalls() []struct {
	S string
} {
	var calls []struct {
		S string
	}
	mock.lockDeviceGetHandleBySerial.RLock()
	calls = mock.calls.DeviceGetHandleBySerial
	mock.lockDeviceGetHandleBySerial.RUnlock()
	return calls
}

// DeviceGetHandleByUUID calls DeviceGetHandleByUUIDFunc.
func (mock *Interface) DeviceGetHandleByUUID(s string) (nvml.Device, nvml.Return) {
	if mock.DeviceGetHandleByUUIDFunc == nil {
		panic("Interface.DeviceGetHandleByUUIDFunc: method is nil but Interface.DeviceGetHandleByUUID was just called")
	}
	callInfo := struct {
		S string
	}{
		S: s,
	}
	mock.lockDeviceGetHandleByUUID.Lock()
	mock.calls.DeviceGetHandleByUUID = append(mock.calls.DeviceGetHandleByUUID, callInfo)
	mock.lockDeviceGetHandleByUUID.Unlock()
	return mock.DeviceGetHandleByUUIDFunc(s)
}

// DeviceGetHandleByUUIDCalls gets all the calls that were made to DeviceGetHandleByUUID.
// Check the length with:
//
//	len(mockedInterface.DeviceGetHandleByUUIDCalls())
func (mock *Interface) DeviceGetHandleByUUIDCalls() []struct {
	S string
} {
	var calls []struct {
		S string
	}
	mock.lockDeviceGetHandleByUUID.RLock()
	calls = mock.calls.DeviceGetHandleByUUID
	mock.lockDeviceGetHandleByUUID.RUnlock()
	return calls
}

// DeviceGetHandleByUUIDV calls DeviceGetHandleByUUIDVFunc.
func (mock *Interface) DeviceGetHandleByUUIDV(uUID *nvml.UUID) (nvml.Device, nvml.Return) {
	if mock.DeviceGetHandleByUUIDVFunc == nil {
		panic("Interface.DeviceGetHandleByUUIDVFunc: method is nil but Interface.DeviceGetHandleByUUIDV was just called")
	}
	callInfo := struct {
		UUID *nvml.UUID
	}{
		UUID: uUID,
	}
	mock.lockDeviceGetHandleByUUIDV.Lock()
	mock.calls.DeviceGetHandleByUUIDV = append(mock.calls.DeviceGetHandleByUUIDV, callInfo)
	mock.lockDeviceGetHandleByUUIDV.Unlock()
	return mock.DeviceGetHandleByUUIDVFunc(uUID)
}

// DeviceGetHandleByUUIDVCalls gets all the calls that were made to DeviceGetHandleByUUIDV.
// Check the length with:
//
//	len(mockedInterface.DeviceGetHandleByUUIDVCalls())
func (mock *Interface) DeviceGetHandleByUUIDVCalls() []struct {
	UUID *nvml.UUID
} {
	var calls []struct {
		UUID *nvml.UUID
	}
	mock.lockDeviceGetHandleByUUIDV.RLock()
	calls = mock.calls.DeviceGetHandleByUUIDV
	mock.lockDeviceGetHandleByUUIDV.RUnlock()
	return calls
}

// DeviceGetHostVgpuMode calls DeviceGetHostVgpuModeFunc.
func (mock *Interface) DeviceGetHostVgpuMode(device nvml.Device) (nvml.HostVgpuMode, nvml.Return) {
	if mock.DeviceGetHostVgpuModeFunc == nil {
		panic("Interface.DeviceGetHostVgpuModeFunc: method is nil but Interface.DeviceGetHostVgpuMode was just called")
	}
	callInfo := struct {
		Device nvml.Device
	}{
		Device: device,
	}
	mock.lockDeviceGetHostVgpuMode.Lock()
	mock.calls.DeviceGetHostVgpuMode = append(mock.calls.DeviceGetHostVgpuMode, callInfo)
	mock.lockDeviceGetHostVgpuMode.Unlock()
	return mock.DeviceGetHostVgpuModeFunc(device)
}

// DeviceGetHostVgpuModeCalls gets all the calls that were made to DeviceGetHostVgpuMode.
// Check the length with:
//
//	len(mockedInterface.DeviceGetHostVgpuModeCalls())
func (mock *Interface) DeviceGetHostVgpuModeCalls() []struct {
	Device nvml.Device
} {
	var calls []struct {
		Device nvml.Device
	}
	mock.lockDeviceGetHostVgpuMode.RLock()
	calls = mock.calls.DeviceGetHostVgpuMode
	mock.lockDeviceGetHostVgpuMode.RUnlock()
	return calls
}

// DeviceGetIndex calls DeviceGetIndexFunc.
func (mock *Interface) DeviceGetIndex(device nvml.Device) (int, nvml.Return) {
	if mock.DeviceGetIndexFunc == nil {
		panic("Interface.DeviceGetIndexFunc: method is nil but Interface.DeviceGetIndex was just called")
	}
	callInfo := struct {
		Device nvml.Device
	}{
		Device: device,
	}
	mock.lockDeviceGetIndex.Lock()
	mock.calls.DeviceGetIndex = append(mock.calls.DeviceGetIndex, callInfo)
	mock.lockDeviceGetIndex.Unlock()
	return mock.DeviceGetIndexFunc(device)
}

// DeviceGetIndexCalls gets all the calls that were made to DeviceGetIndex.
// Check the length with:
//
//	len(mockedInterface.DeviceGetIndexCalls())
func (mock *Interface) DeviceGetIndexCalls() []struct {
	Device nvml.Device
} {
	var calls []struct {
		Device nvml.Device
	}
	mock.lockDeviceGetIndex.RLock()
	calls = mock.calls.DeviceGetIndex
	mock.lockDeviceGetIndex.RUnlock()
	return calls
}

// DeviceGetInforomConfigurationChecksum calls DeviceGetInforomConfigurationChecksumFunc.
func (mock *Interface) DeviceGetInforomConfigurationChecksum(device nvml.Device) (uint32, nvml.Return) {
	if mock.DeviceGetInforomConfigurationChecksumFunc == nil {
		panic("Interface.DeviceGetInforomConfigurationChecksumFunc: method is nil but Interface.DeviceGetInforomConfigurationChecksum was just called")
	}
	callInfo := struct {
		Device nvml.Device
	}{
		Device: device,
	}
	mock.lockDeviceGetInforomConfigurationChecksum.Lock()
	mock.calls.DeviceGetInforomConfigurationChecksum = append(mock.calls.DeviceGetInforomConfigurationChecksum, callInfo)
	mock.lockDeviceGetInforomConfigurationChecksum.Unlock()
	return mock.DeviceGetInforomConfigurationChecksumFunc(device)
}

// DeviceGetInforomConfigurationChecksumCalls gets all the calls that were made to DeviceGetInforomConfigurationChecksum.
// Check the length with:
//
//	len(mockedInterface.DeviceGetInforomConfigurationChecksumCalls())
func (mock *Interface) DeviceGetInforomConfigurationChecksumCalls() []struct {
	Device nvml.Device
} {
	var calls []struct {
		Device nvml.Device
	}
	mock.lockDeviceGetInforomConfigurationChecksum.RLock()
	calls = mock.calls.DeviceGetInforomConfigurationChecksum
	mock.lockDeviceGetInforomConfigurationChecksum.RUnlock()
	return calls
}

// DeviceGetInforomImageVersion calls DeviceGetInforomImageVersionFunc.
func (mock *Interface) DeviceGetInforomImageVersion(device nvml.Device) (string, nvml.Return) {
	if mock.DeviceGetInforomImageVersionFunc == nil {
		panic("Interface.DeviceGetInforomImageVersionFunc: method is nil but Interface.DeviceGetInforomImageVersion was just called")
	}
	callInfo := struct {
		Device nvml.Device
	}{
		Device: device,
	}
	mock.lockDeviceGetInforomImageVersion.Lock()
	mock.calls.DeviceGetInforomImageVersion = append(mock.calls.DeviceGetInforomImageVersion, callInfo)
	mock.lockDeviceGetInforomImageVersion.Unlock()
	return mock.DeviceGetInforomImageVersionFunc(device)
}

// DeviceGetInforomImageVersionCalls gets all the calls that were made to DeviceGetInforomImageVersion.
// Check the length with:
//
//	len(mockedInterface.DeviceGetInforomImageVersionCalls())
func (mock *Interface) DeviceGetInforomImageVersionCalls() []struct {
	Device nvml.Device
} {
	var calls []struct {
		Device nvml.Device
	}
	mock.lockDeviceGetInforomImageVersion.RLock()
	calls = mock.calls.DeviceGetInforomImageVersion
	mock.lockDeviceGetInforomImageVersion.RUnlock()
	return calls
}

// DeviceGetInforomVersion calls DeviceGetInforomVersionFunc.
func (mock *Interface) DeviceGetInforomVersion(device nvml.Device, inforomObject nvml.InforomObject) (string, nvml.Return) {
	if mock.DeviceGetInforomVersionFunc == nil {
		panic("Interface.DeviceGetInforomVersionFunc: method is nil but Interface.DeviceGetInforomVersion was just called")
	}
	callInfo := struct {
		Device        nvml.Device
		InforomObject nvml.InforomObject
	}{
		Device:        device,
		InforomObject: inforomObject,
	}
	mock.lockDeviceGetInforomVersion.Lock()
	mock.calls.DeviceGetInforomVersion = append(mock.calls.DeviceGetInforomVersion, callInfo)
	mock.lockDeviceGetInforomVersion.Unlock()
	return mock.DeviceGetInforomVersionFunc(device, inforomObject)
}

// DeviceGetInforomVersionCalls gets all the calls that were made to DeviceGetInforomVersion.
// Check the length with:
//
//	len(mockedInterface.DeviceGetInforomVersionCalls())
func (mock *Interface) DeviceGetInforomVersionCalls() []struct {
	Device        nvml.Device
	InforomObject nvml.InforomObject
} {
	var calls []struct {
		Device        nvml.Device
		InforomObject nvml.InforomObject
	}
	mock.lockDeviceGetInforomVersion.RLock()
	calls = mock.calls.DeviceGetInforomVersion
	mock.lockDeviceGetInforomVersion.RUnlock()
	return calls
}

// DeviceGetIrqNum calls DeviceGetIrqNumFunc.
func (mock *Interface) DeviceGetIrqNum(device nvml.Device) (int, nvml.Return) {
	if mock.DeviceGetIrqNumFunc == nil {
		panic("Interface.DeviceGetIrqNumFunc: method is nil but Interface.DeviceGetIrqNum was just called")
	}
	callInfo := struct {
		Device nvml.Device
	}{
		Device: device,
	}
	mock.lockDeviceGetIrqNum.Lock()
	mock.calls.DeviceGetIrqNum = append(mock.calls.DeviceGetIrqNum, callInfo)
	mock.lockDeviceGetIrqNum.Unlock()
	return mock.DeviceGetIrqNumFunc(device)
}

// DeviceGetIrqNumCalls gets all the calls that were made to DeviceGetIrqNum.
// Check the length with:
//
//	len(mockedInterface.DeviceGetIrqNumCalls())
func (mock *Interface) DeviceGetIrqNumCalls() []struct {
	Device nvml.Device
} {
	var calls []struct {
		Device nvml.Device
	}
	mock.lockDeviceGetIrqNum.RLock()
	calls = mock.calls.DeviceGetIrqNum
	mock.lockDeviceGetIrqNum.RUnlock()
	return calls
}

// DeviceGetJpgUtilization calls DeviceGetJpgUtilizationFunc.
func (mock *Interface) DeviceGetJpgUtilization(device nvml.Device) (uint32, uint32, nvml.Return) {
	if mock.DeviceGetJpgUtilizationFunc == nil {
		panic("Interface.DeviceGetJpgUtilizationFunc: method is nil but Interface.DeviceGetJpgUtilization was just called")
	}
	callInfo := struct {
		Device nvml.Device
	}{
		Device: device,
	}
	mock.lockDeviceGetJpgUtilization.Lock()
	mock.calls.DeviceGetJpgUtilization = append(mock.calls.DeviceGetJpgUtilization, callInfo)
	mock.lockDeviceGetJpgUtilization.Unlock()
	return mock.DeviceGetJpgUtilizationFunc(device)
}

// DeviceGetJpgUtilizationCalls gets all the calls that were made to DeviceGetJpgUtilization.
// Check the length with:
//
//	len(mockedInterface.DeviceGetJpgUtilizationCalls())
func (mock *Interface) DeviceGetJpgUtilizationCalls() []struct {
	Device nvml.Device
} {
	var calls []struct {
		Device nvml.Device
	}
	mock.lockDeviceGetJpgUtilization.RLock()
	calls = mock.calls.DeviceGetJpgUtilization
	mock.lockDeviceGetJpgUtilization.RUnlock()
	return calls
}

// DeviceGetLastBBXFlushTime calls DeviceGetLastBBXFlushTimeFunc.
func (mock *Interface) DeviceGetLastBBXFlushTime(device nvml.Device) (uint64, uint, nvml.Return) {
	if mock.DeviceGetLastBBXFlushTimeFunc == nil {
		panic("Interface.DeviceGetLastBBXFlushTimeFunc: method is nil but Interface.DeviceGetLastBBXFlushTime was just called")
	}
	callInfo := struct {
		Device nvml.Device
	}{
		Device: device,
	}
	mock.lockDeviceGetLastBBXFlushTime.Lock()
	mock.calls.DeviceGetLastBBXFlushTime = append(mock.calls.DeviceGetLastBBXFlushTime, callInfo)
	mock.lockDeviceGetLastBBXFlushTime.Unlock()
	return mock.DeviceGetLastBBXFlushTimeFunc(device)
}

// DeviceGetLastBBXFlushTimeCalls gets all the calls that were made to DeviceGetLastBBXFlushTime.
// Check the length with:
//
//	len(mockedInterface.DeviceGetLastBBXFlushTimeCalls())
func (mock *Interface) DeviceGetLastBBXFlushTimeCalls() []struct {
	Device nvml.Device
} {
	var calls []struct {
		Device nvml.Device
	}
	mock.lockDeviceGetLastBBXFlushTime.RLock()
	calls = mock.calls.DeviceGetLastBBXFlushTime
	mock.lockDeviceGetLastBBXFlushTime.RUnlock()
	return calls
}

// DeviceGetMPSComputeRunningProcesses calls DeviceGetMPSComputeRunningProcessesFunc.
func (mock *Interface) DeviceGetMPSComputeRunningProcesses(device nvml.Device) ([]nvml.ProcessInfo, nvml.Return) {
	if mock.DeviceGetMPSComputeRunningProcessesFunc == nil {
		panic("Interface.DeviceGetMPSComputeRunningProcessesFunc: method is nil but Interface.DeviceGetMPSComputeRunningProcesses was just called")
	}
	callInfo := struct {
		Device nvml.Device
	}{
		Device: device,
	}
	mock.lockDeviceGetMPSComputeRunningProcesses.Lock()
	mock.calls.DeviceGetMPSComputeRunningProcesses = append(mock.calls.DeviceGetMPSComputeRunningProcesses, callInfo)
	mock.lockDeviceGetMPSComputeRunningProcesses.Unlock()
	return mock.DeviceGetMPSComputeRunningProcessesFunc(device)
}

// DeviceGetMPSComputeRunningProcessesCalls gets all the calls that were made to DeviceGetMPSComputeRunningProcesses.
// Check the length with:
//
//	len(mockedInterface.DeviceGetMPSComputeRunningProcessesCalls())
func (mock *Interface) DeviceGetMPSComputeRunningProcessesCalls() []struct {
	Device nvml.Device
} {
	var calls []struct {
		Device nvml.Device
	}
	mock.lockDeviceGetMPSComputeRunningProcesses.RLock()
	calls = mock.calls.DeviceGetMPSComputeRunningProcesses
	mock.lockDeviceGetMPSComputeRunningProcesses.RUnlock()
	return calls
}

// DeviceGetMarginTemperature calls DeviceGetMarginTemperatureFunc.
func (mock *Interface) DeviceGetMarginTemperature(device nvml.Device) (nvml.MarginTemperature, nvml.Return) {
	if mock.DeviceGetMarginTemperatureFunc == nil {
		panic("Interface.DeviceGetMarginTemperatureFunc: method is nil but Interface.DeviceGetMarginTemperature was just called")
	}
	callInfo := struct {
		Device nvml.Device
	}{
		Device: device,
	}
	mock.lockDeviceGetMarginTemperature.Lock()
	mock.calls.DeviceGetMarginTemperature = append(mock.calls.DeviceGetMarginTemperature, callInfo)
	mock.lockDeviceGetMarginTemperature.Unlock()
	return mock.DeviceGetMarginTemperatureFunc(device)
}

// DeviceGetMarginTemperatureCalls gets all the calls that were made to DeviceGetMarginTemperature.
// Check the length with:
//
//	len(mockedInterface.DeviceGetMarginTemperatureCalls())
func (mock *Interface) DeviceGetMarginTemperatureCalls() []struct {
	Device nvml.Device
} {
	var calls []struct {
		Device nvml.Device
	}
	mock.lockDeviceGetMarginTemperature.RLock()
	calls = mock.calls.DeviceGetMarginTemperature
	mock.lockDeviceGetMarginTemperature.RUnlock()
	return calls
}

// DeviceGetMaxClockInfo calls DeviceGetMaxClockInfoFunc.
func (mock *Interface) DeviceGetMaxClockInfo(device nvml.Device, clockType nvml.ClockType) (uint32, nvml.Return) {
	if mock.DeviceGetMaxClockInfoFunc == nil {
		panic("Interface.DeviceGetMaxClockInfoFunc: method is nil but Interface.DeviceGetMaxClockInfo was just called")
	}
	callInfo := struct {
		Device    nvml.Device
		ClockType nvml.ClockType
	}{
		Device:    device,
		ClockType: clockType,
	}
	mock.lockDeviceGetMaxClockInfo.Lock()
	mock.calls.DeviceGetMaxClockInfo = append(mock.calls.DeviceGetMaxClockInfo, callInfo)
	mock.lockDeviceGetMaxClockInfo.Unlock()
	return mock.DeviceGetMaxClockInfoFunc(device, clockType)
}

// DeviceGetMaxClockInfoCalls gets all the calls that were made to DeviceGetMaxClockInfo.
// Check the length with:
//
//	len(mockedInterface.DeviceGetMaxClockInfoCalls())
func (mock *Interface) DeviceGetMaxClockInfoCalls() []struct {
	Device    nvml.Device
	ClockType nvml.ClockType
} {
	var calls []struct {
		Device    nvml.Device
		ClockType nvml.ClockType
	}
	mock.lockDeviceGetMaxClockInfo.RLock()
	calls = mock.calls.DeviceGetMaxClockInfo
	mock.lockDeviceGetMaxClockInfo.RUnlock()
	return calls
}

// DeviceGetMaxCustomerBoostClock calls DeviceGetMaxCustomerBoostClockFunc.
func (mock *Interface) DeviceGetMaxCustomerBoostClock(device nvml.Device, clockType nvml.ClockType) (uint32, nvml.Return) {
	if mock.DeviceGetMaxCustomerBoostClockFunc == nil {
		panic("Interface.DeviceGetMaxCustomerBoostClockFunc: method is nil but Interface.DeviceGetMaxCustomerBoostClock was just called")
	}
	callInfo := struct {
		Device    nvml.Device
		ClockType nvml.ClockType
	}{
		Device:    device,
		ClockType: clockType,
	}
	mock.lockDeviceGetMaxCustomerBoostClock.Lock()
	mock.calls.DeviceGetMaxCustomerBoostClock = append(mock.calls.DeviceGetMaxCustomerBoostClock, callInfo)
	mock.lockDeviceGetMaxCustomerBoostClock.Unlock()
	return mock.DeviceGetMaxCustomerBoostClockFunc(device, clockType)
}

// DeviceGetMaxCustomerBoostClockCalls gets all the calls that were made to DeviceGetMaxCustomerBoostClock.
// Check the length with:
//
//	len(mockedInterface.DeviceGetMaxCustomerBoostClockCalls())
func (mock *Interface) DeviceGetMaxCustomerBoostClockCalls() []struct {
	Device    nvml.Device
	ClockType nvml.ClockType
} {
	var calls []struct {
		Device    nvml.Device
		ClockType nvml.ClockType
	}
	mock.lockDeviceGetMaxCustomerBoostClock.RLock()
	calls = mock.calls.DeviceGetMaxCustomerBoostClock
	mock.lockDeviceGetMaxCustomerBoostClock.RUnlock()
	return calls
}

// DeviceGetMaxMigDeviceCount calls DeviceGetMaxMigDeviceCountFunc.
func (mock *Interface) DeviceGetMaxMigDeviceCount(device nvml.Device) (int, nvml.Return) {
	if mock.DeviceGetMaxMigDeviceCountFunc == nil {
		panic("Interface.DeviceGetMaxMigDeviceCountFunc: method is nil but Interface.DeviceGetMaxMigDeviceCount was just called")
	}
	callInfo := struct {
		Device nvml.Device
	}{
		Device: device,
	}
	mock.lockDeviceGetMaxMigDeviceCount.Lock()
	mock.calls.DeviceGetMaxMigDeviceCount = append(mock.calls.DeviceGetMaxMigDeviceCount, callInfo)
	mock.lockDeviceGetMaxMigDeviceCount.Unlock()
	return mock.DeviceGetMaxMigDeviceCountFunc(device)
}

// DeviceGetMaxMigDeviceCountCalls gets all the calls that were made to DeviceGetMaxMigDeviceCount.
// Check the length with:
//
//	len(mockedInterface.DeviceGetMaxMigDeviceCountCalls())
func (mock *Interface) DeviceGetMaxMigDeviceCountCalls() []struct {
	Device nvml.Device
} {
	var calls []struct {
		Device nvml.Device
	}
	mock.lockDeviceGetMaxMigDeviceCount.RLock()
	calls = mock.calls.DeviceGetMaxMigDeviceCount
	mock.lockDeviceGetMaxMigDeviceCount.RUnlock()
	return calls
}

// DeviceGetMaxPcieLinkGeneration calls DeviceGetMaxPcieLinkGenerationFunc.
func (mock *Interface) DeviceGetMaxPcieLinkGeneration(device nvml.Device) (int, nvml.Return) {
	if mock.DeviceGetMaxPcieLinkGenerationFunc == nil {
		panic("Interface.DeviceGetMaxPcieLinkGenerationFunc: method is nil but Interface.DeviceGetMaxPcieLinkGeneration was just called")
	}
	callInfo := struct {
		Device nvml.Device
	}{
		Device: device,
	}
	mock.lockDeviceGetMaxPcieLinkGeneration.Lock()
	mock.calls.DeviceGetMaxPcieLinkGeneration = append(mock.calls.DeviceGetMaxPcieLinkGeneration, callInfo)
	mock.lockDeviceGetMaxPcieLinkGeneration.Unlock()
	return mock.DeviceGetMaxPcieLinkGenerationFunc(device)
}

// DeviceGetMaxPcieLinkGenerationCalls gets all the calls that were made to DeviceGetMaxPcieLinkGeneration.
// Check the length with:
//
//	len(mockedInterface.DeviceGetMaxPcieLinkGenerationCalls())
func (mock *Interface) DeviceGetMaxPcieLinkGenerationCalls() []struct {
	Device nvml.Device
} {
	var calls []struct {
		Device nvml.Device
	}
	mock.lockDeviceGetMaxPcieLinkGeneration.RLock()
	calls = mock.calls.DeviceGetMaxPcieLinkGeneration
	mock.lockDeviceGetMaxPcieLinkGeneration.RUnlock()
	return calls
}

// DeviceGetMaxPcieLinkWidth calls DeviceGetMaxPcieLinkWidthFunc.
func (mock *Interface) DeviceGetMaxPcieLinkWidth(device nvml.Device) (int, nvml.Return) {
	if mock.DeviceGetMaxPcieLinkWidthFunc == nil {
		panic("Interface.DeviceGetMaxPcieLinkWidthFunc: method is nil but Interface.DeviceGetMaxPcieLinkWidth was just called")
	}
	callInfo := struct {
		Device nvml.Device
	}{
		Device: device,
	}
	mock.lockDeviceGetMaxPcieLinkWidth.Lock()
	mock.calls.DeviceGetMaxPcieLinkWidth = append(mock.calls.DeviceGetMaxPcieLinkWidth, callInfo)
	mock.lockDeviceGetMaxPcieLinkWidth.Unlock()
	return mock.DeviceGetMaxPcieLinkWidthFunc(device)
}

// DeviceGetMaxPcieLinkWidthCalls gets all the calls that were made to DeviceGetMaxPcieLinkWidth.
// Check the length with:
//
//	len(mockedInterface.DeviceGetMaxPcieLinkWidthCalls())
func (mock *Interface) DeviceGetMaxPcieLinkWidthCalls() []struct {
	Device nvml.Device
} {
	var calls []struct {
		Device nvml.Device
	}
	mock.lockDeviceGetMaxPcieLinkWidth.RLock()
	calls = mock.calls.DeviceGetMaxPcieLinkWidth
	mock.lockDeviceGetMaxPcieLinkWidth.RUnlock()
	return calls
}

// DeviceGetMemClkMinMaxVfOffset calls DeviceGetMemClkMinMaxVfOffsetFunc.
func (mock *Interface) DeviceGetMemClkMinMaxVfOffset(device nvml.Device) (int, int, nvml.Return) {
	if mock.DeviceGetMemClkMinMaxVfOffsetFunc == nil {
		panic("Interface.DeviceGetMemClkMinMaxVfOffsetFunc: method is nil but Interface.DeviceGetMemClkMinMaxVfOffset was just called")
	}
	callInfo := struct {
		Device nvml.Device
	}{
		Device: device,
	}
	mock.lockDeviceGetMemClkMinMaxVfOffset.Lock()
	mock.calls.DeviceGetMemClkMinMaxVfOffset = append(mock.calls.DeviceGetMemClkMinMaxVfOffset, callInfo)
	mock.lockDeviceGetMemClkMinMaxVfOffset.Unlock()
	return mock.DeviceGetMemClkMinMaxVfOffsetFunc(device)
}

// DeviceGetMemClkMinMaxVfOffsetCalls gets all the calls that were made to DeviceGetMemClkMinMaxVfOffset.
// Check the length with:
//
//	len(mockedInterface.DeviceGetMemClkMinMaxVfOffsetCalls())
func (mock *Interface) DeviceGetMemClkMinMaxVfOffsetCalls() []struct {
	Device nvml.Device
} {
	var calls []struct {
		Device nvml.Device
	}
	mock.lockDeviceGetMemClkMinMaxVfOffset.RLock()
	calls = mock.calls.DeviceGetMemClkMinMaxVfOffset
	mock.lockDeviceGetMemClkMinMaxVfOffset.RUnlock()
	return calls
}

// DeviceGetMemClkVfOffset calls DeviceGetMemClkVfOffsetFunc.
func (mock *Interface) DeviceGetMemClkVfOffset(device nvml.Device) (int, nvml.Return) {
	if mock.DeviceGetMemClkVfOffsetFunc == nil {
		panic("Interface.DeviceGetMemClkVfOffsetFunc: method is nil but Interface.DeviceGetMemClkVfOffset was just called")
	}
	callInfo := struct {
		Device nvml.Device
	}{
		Device: device,
	}
	mock.lockDeviceGetMemClkVfOffset.Lock()
	mock.calls.DeviceGetMemClkVfOffset = append(mock.calls.DeviceGetMemClkVfOffset, callInfo)
	mock.lockDeviceGetMemClkVfOffset.Unlock()
	return mock.DeviceGetMemClkVfOffsetFunc(device)
}

// DeviceGetMemClkVfOffsetCalls gets all the calls that were made to DeviceGetMemClkVfOffset.
// Check the length with:
//
//	len(mockedInterface.DeviceGetMemClkVfOffsetCalls())
func (mock *Interface) DeviceGetMemClkVfOffsetCalls() []struct {
	Device nvml.Device
} {
	var calls []struct {
		Device nvml.Device
	}
	mock.lockDeviceGetMemClkVfOffset.RLock()
	calls = mock.calls.DeviceGetMemClkVfOffset
	mock.lockDeviceGetMemClkVfOffset.RUnlock()
	return calls
}

// DeviceGetMemoryAffinity calls DeviceGetMemoryAffinityFunc.
func (mock *Interface) DeviceGetMemoryAffinity(device nvml.Device, n int, affinityScope nvml.AffinityScope) ([]uint, nvml.Return) {
	if mock.DeviceGetMemoryAffinityFunc == nil {
		panic("Interface.DeviceGetMemoryAffinityFunc: method is nil but Interface.DeviceGetMemoryAffinity was just called")
	}
	callInfo := struct {
		Device        nvml.Device
		N             int
		AffinityScope nvml.AffinityScope
	}{
		Device:        device,
		N:             n,
		AffinityScope: affinityScope,
	}
	mock.lockDeviceGetMemoryAffinity.Lock()
	mock.calls.DeviceGetMemoryAffinity = append(mock.calls.DeviceGetMemoryAffinity, callInfo)
	mock.lockDeviceGetMemoryAffinity.Unlock()
	return mock.DeviceGetMemoryAffinityFunc(device, n, affinityScope)
}

// DeviceGetMemoryAffinityCalls gets all the calls that were made to DeviceGetMemoryAffinity.
// Check the length with:
//
//	len(mockedInterface.DeviceGetMemoryAffinityCalls())
func (mock *Interface) DeviceGetMemoryAffinityCalls() []struct {
	Device        nvml.Device
	N             int
	AffinityScope nvml.AffinityScope
} {
	var calls []struct {
		Device        nvml.Device
		N             int
		AffinityScope nvml.AffinityScope
	}
	mock.lockDeviceGetMemoryAffinity.RLock()
	calls = mock.calls.DeviceGetMemoryAffinity
	mock.lockDeviceGetMemoryAffinity.RUnlock()
	return calls
}

// DeviceGetMemoryBusWidth calls DeviceGetMemoryBusWidthFunc.
func (mock *Interface) DeviceGetMemoryBusWidth(device nvml.Device) (uint32, nvml.Return) {
	if mock.DeviceGetMemoryBusWidthFunc == nil {
		panic("Interface.DeviceGetMemoryBusWidthFunc: method is nil but Interface.DeviceGetMemoryBusWidth was just called")
	}
	callInfo := struct {
		Device nvml.Device
	}{
		Device: device,
	}
	mock.lockDeviceGetMemoryBusWidth.Lock()
	mock.calls.DeviceGetMemoryBusWidth = append(mock.calls.DeviceGetMemoryBusWidth, callInfo)
	mock.lockDeviceGetMemoryBusWidth.Unlock()
	return mock.DeviceGetMemoryBusWidthFunc(device)
}

// DeviceGetMemoryBusWidthCalls gets all the calls that were made to DeviceGetMemoryBusWidth.
// Check the length with:
//
//	len(mockedInterface.DeviceGetMemoryBusWidthCalls())
func (mock *Interface) DeviceGetMemoryBusWidthCalls() []struct {
	Device nvml.Device
} {
	var calls []struct {
		Device nvml.Device
	}
	mock.lockDeviceGetMemoryBusWidth.RLock()
	calls = mock.calls.DeviceGetMemoryBusWidth
	mock.lockDeviceGetMemoryBusWidth.RUnlock()
	return calls
}

// DeviceGetMemoryErrorCounter calls DeviceGetMemoryErrorCounterFunc.
func (mock *Interface) DeviceGetMemoryErrorCounter(device nvml.Device, memoryErrorType nvml.MemoryErrorType, eccCounterType nvml.EccCounterType, memoryLocation nvml.MemoryLocation) (uint64, nvml.Return) {
	if mock.DeviceGetMemoryErrorCounterFunc == nil {
		panic("Interface.DeviceGetMemoryErrorCounterFunc: method is nil but Interface.DeviceGetMemoryErrorCounter was just called")
	}
	callInfo := struct {
		Device          nvml.Device
		MemoryErrorType nvml.MemoryErrorType
		EccCounterType  nvml.EccCounterType
		MemoryLocation  nvml.MemoryLocation
	}{
		Device:          device,
		MemoryErrorType: memoryErrorType,
		EccCounterType:  eccCounterType,
		MemoryLocation:  memoryLocation,
	}
	mock.lockDeviceGetMemoryErrorCounter.Lock()
	mock.calls.DeviceGetMemoryErrorCounter = append(mock.calls.DeviceGetMemoryErrorCounter, callInfo)
	mock.lockDeviceGetMemoryErrorCounter.Unlock()
	return mock.DeviceGetMemoryErrorCounterFunc(device, memoryErrorType, eccCounterType, memoryLocation)
}

// DeviceGetMemoryErrorCounterCalls gets all the calls that were made to DeviceGetMemoryErrorCounter.
// Check the length with:
//
//	len(mockedInterface.DeviceGetMemoryErrorCounterCalls())
func (mock *Interface) DeviceGetMemoryErrorCounterCalls() []struct {
	Device          nvml.Device
	MemoryErrorType nvml.MemoryErrorType
	EccCounterType  nvml.EccCounterType
	MemoryLocation  nvml.MemoryLocation
} {
	var calls []struct {
		Device          nvml.Device
		MemoryErrorType nvml.MemoryErrorType
		EccCounterType  nvml.EccCounterType
		MemoryLocation  nvml.MemoryLocation
	}
	mock.lockDeviceGetMemoryErrorCounter.RLock()
	calls = mock.calls.DeviceGetMemoryErrorCounter
	mock.lockDeviceGetMemoryErrorCounter.RUnlock()
	return calls
}

// DeviceGetMemoryInfo calls DeviceGetMemoryInfoFunc.
func (mock *Interface) DeviceGetMemoryInfo(device nvml.Device) (nvml.Memory, nvml.Return) {
	if mock.DeviceGetMemoryInfoFunc == nil {
		panic("Interface.DeviceGetMemoryInfoFunc: method is nil but Interface.DeviceGetMemoryInfo was just called")
	}
	callInfo := struct {
		Device nvml.Device
	}{
		Device: device,
	}
	mock.lockDeviceGetMemoryInfo.Lock()
	mock.calls.DeviceGetMemoryInfo = append(mock.calls.DeviceGetMemoryInfo, callInfo)
	mock.lockDeviceGetMemoryInfo.Unlock()
	return mock.DeviceGetMemoryInfoFunc(device)
}

// DeviceGetMemoryInfoCalls gets all the calls that were made to DeviceGetMemoryInfo.
// Check the length with:
//
//	len(mockedInterface.DeviceGetMemoryInfoCalls())
func (mock *Interface) DeviceGetMemoryInfoCalls() []struct {
	Device nvml.Device
} {
	var calls []struct {
		Device nvml.Device
	}
	mock.lockDeviceGetMemoryInfo.RLock()
	calls = mock.calls.DeviceGetMemoryInfo
	mock.lockDeviceGetMemoryInfo.RUnlock()
	return calls
}

// DeviceGetMemoryInfo_v2 calls DeviceGetMemoryInfo_v2Func.
func (mock *Interface) DeviceGetMemoryInfo_v2(device nvml.Device) (nvml.Memory_v2, nvml.Return) {
	if mock.DeviceGetMemoryInfo_v2Func == nil {
		panic("Interface.DeviceGetMemoryInfo_v2Func: method is nil but Interface.DeviceGetMemoryInfo_v2 was just called")
	}
	callInfo := struct {
		Device nvml.Device
	}{
		Device: device,
	}
	mock.lockDeviceGetMemoryInfo_v2.Lock()
	mock.calls.DeviceGetMemoryInfo_v2 = append(mock.calls.DeviceGetMemoryInfo_v2, callInfo)
	mock.lockDeviceGetMemoryInfo_v2.Unlock()
	return mock.DeviceGetMemoryInfo_v2Func(device)
}

// DeviceGetMemoryInfo_v2Calls gets all the calls that were made to DeviceGetMemoryInfo_v2.
// Check the length with:
//
//	len(mockedInterface.DeviceGetMemoryInfo_v2Calls())
func (mock *Interface) DeviceGetMemoryInfo_v2Calls() []struct {
	Device nvml.Device
} {
	var calls []struct {
		Device nvml.Device
	}
	mock.lockDeviceGetMemoryInfo_v2.RLock()
	calls = mock.calls.DeviceGetMemoryInfo_v2
	mock.lockDeviceGetMemoryInfo_v2.RUnlock()
	return calls
}

// DeviceGetMigDeviceHandleByIndex calls DeviceGetMigDeviceHandleByIndexFunc.
func (mock *Interface) DeviceGetMigDeviceHandleByIndex(device nvml.Device, n int) (nvml.Device, nvml.Return) {
	if mock.DeviceGetMigDeviceHandleByIndexFunc == nil {
		panic("Interface.DeviceGetMigDeviceHandleByIndexFunc: method is nil but Interface.DeviceGetMigDeviceHandleByIndex was just called")
	}
	callInfo := struct {
		Device nvml.Device
		N      int
	}{
		Device: device,
		N:      n,
	}
	mock.lockDeviceGetMigDeviceHandleByIndex.Lock()
	mock.calls.DeviceGetMigDeviceHandleByIndex = append(mock.calls.DeviceGetMigDeviceHandleByIndex, callInfo)
	mock.lockDeviceGetMigDeviceHandleByIndex.Unlock()
	return mock.DeviceGetMigDeviceHandleByIndexFunc(device, n)
}

// DeviceGetMigDeviceHandleByIndexCalls gets all the calls that were made to DeviceGetMigDeviceHandleByIndex.
// Check the length with:
//
//	len(mockedInterface.DeviceGetMigDeviceHandleByIndexCalls())
func (mock *Interface) DeviceGetMigDeviceHandleByIndexCalls() []struct {
	Device nvml.Device
	N      int
} {
	var calls []struct {
		Device nvml.Device
		N      int
	}
	mock.lockDeviceGetMigDeviceHandleByIndex.RLock()
	calls = mock.calls.DeviceGetMigDeviceHandleByIndex
	mock.lockDeviceGetMigDeviceHandleByIndex.RUnlock()
	return calls
}

// DeviceGetMigMode calls DeviceGetMigModeFunc.
func (mock *Interface) DeviceGetMigMode(device nvml.Device) (int, int, nvml.Return) {
	if mock.DeviceGetMigModeFunc == nil {
		panic("Interface.DeviceGetMigModeFunc: method is nil but Interface.DeviceGetMigMode was just called")
	}
	callInfo := struct {
		Device nvml.Device
	}{
		Device: device,
	}
	mock.lockDeviceGetMigMode.Lock()
	mock.calls.DeviceGetMigMode = append(mock.calls.DeviceGetMigMode, callInfo)
	mock.lockDeviceGetMigMode.Unlock()
	return mock.DeviceGetMigModeFunc(device)
}

// DeviceGetMigModeCalls gets all the calls that were made to DeviceGetMigMode.
// Check the length with:
//
//	len(mockedInterface.DeviceGetMigModeCalls())
func (mock *Interface) DeviceGetMigModeCalls() []struct {
	Device nvml.Device
} {
	var calls []struct {
		Device nvml.Device
	}
	mock.lockDeviceGetMigMode.RLock()
	calls = mock.calls.DeviceGetMigMode
	mock.lockDeviceGetMigMode.RUnlock()
	return calls
}

// DeviceGetMinMaxClockOfPState calls DeviceGetMinMaxClockOfPStateFunc.
func (mock *Interface) DeviceGetMinMaxClockOfPState(device nvml.Device, clockType nvml.ClockType, pstates nvml.Pstates) (uint32, uint32, nvml.Return) {
	if mock.DeviceGetMinMaxClockOfPStateFunc == nil {
		panic("Interface.DeviceGetMinMaxClockOfPStateFunc: method is nil but Interface.DeviceGetMinMaxClockOfPState was just called")
	}
	callInfo := struct {
		Device    nvml.Device
		ClockType nvml.ClockType
		Pstates   nvml.Pstates
	}{
		Device:    device,
		ClockType: clockType,
		Pstates:   pstates,
	}
	mock.lockDeviceGetMinMaxClockOfPState.Lock()
	mock.calls.DeviceGetMinMaxClockOfPState = append(mock.calls.DeviceGetMinMaxClockOfPState, callInfo)
	mock.lockDeviceGetMinMaxClockOfPState.Unlock()
	return mock.DeviceGetMinMaxClockOfPStateFunc(device, clockType, pstates)
}

// DeviceGetMinMaxClockOfPStateCalls gets all the calls that were made to DeviceGetMinMaxClockOfPState.
// Check the length with:
//
//	len(mockedInterface.DeviceGetMinMaxClockOfPStateCalls())
func (mock *Interface) DeviceGetMinMaxClockOfPStateCalls() []struct {
	Device    nvml.Device
	ClockType nvml.ClockType
	Pstates   nvml.Pstates
} {
	var calls []struct {
		Device    nvml.Device
		ClockType nvml.ClockType
		Pstates   nvml.Pstates
	}
	mock.lockDeviceGetMinMaxClockOfPState.RLock()
	calls = mock.calls.DeviceGetMinMaxClockOfPState
	mock.lockDeviceGetMinMaxClockOfPState.RUnlock()
	return calls
}

// DeviceGetMinMaxFanSpeed calls DeviceGetMinMaxFanSpeedFunc.
func (mock *Interface) DeviceGetMinMaxFanSpeed(device nvml.Device) (int, int, nvml.Return) {
	if mock.DeviceGetMinMaxFanSpeedFunc == nil {
		panic("Interface.DeviceGetMinMaxFanSpeedFunc: method is nil but Interface.DeviceGetMinMaxFanSpeed was just called")
	}
	callInfo := struct {
		Device nvml.Device
	}{
		Device: device,
	}
	mock.lockDeviceGetMinMaxFanSpeed.Lock()
	mock.calls.DeviceGetMinMaxFanSpeed = append(mock.calls.DeviceGetMinMaxFanSpeed, callInfo)
	mock.lockDeviceGetMinMaxFanSpeed.Unlock()
	return mock.DeviceGetMinMaxFanSpeedFunc(device)
}

// DeviceGetMinMaxFanSpeedCalls gets all the calls that were made to DeviceGetMinMaxFanSpeed.
// Check the length with:
//
//	len(mockedInterface.DeviceGetMinMaxFanSpeedCalls())
func (mock *Interface) DeviceGetMinMaxFanSpeedCalls() []struct {
	Device nvml.Device
} {
	var calls []struct {
		Device nvml.Device
	}
	mock.lockDeviceGetMinMaxFanSpeed.RLock()
	calls = mock.calls.DeviceGetMinMaxFanSpeed
	mock.lockDeviceGetMinMaxFanSpeed.RUnlock()
	return calls
}

// DeviceGetMinorNumber calls DeviceGetMinorNumberFunc.
func (mock *Interface) DeviceGetMinorNumber(device nvml.Device) (int, nvml.Return) {
	if mock.DeviceGetMinorNumberFunc == nil {
		panic("Interface.DeviceGetMinorNumberFunc: method is nil but Interface.DeviceGetMinorNumber was just called")
	}
	callInfo := struct {
		Device nvml.Device
	}{
		Device: device,
	}
	mock.lockDeviceGetMinorNumber.Lock()
	mock.calls.DeviceGetMinorNumber = append(mock.calls.DeviceGetMinorNumber, callInfo)
	mock.lockDeviceGetMinorNumber.Unlock()
	return mock.DeviceGetMinorNumberFunc(device)
}

// DeviceGetMinorNumberCalls gets all the calls that were made to DeviceGetMinorNumber.
// Check the length with:
//
//	len(mockedInterface.DeviceGetMinorNumberCalls())
func (mock *Interface) DeviceGetMinorNumberCalls() []struct {
	Device nvml.Device
} {
	var calls []struct {
		Device nvml.Device
	}
	mock.lockDeviceGetMinorNumber.RLock()
	calls = mock.calls.DeviceGetMinorNumber
	mock.lockDeviceGetMinorNumber.RUnlock()
	return calls
}

// DeviceGetModuleId calls DeviceGetModuleIdFunc.
func (mock *Interface) DeviceGetModuleId(device nvml.Device) (int, nvml.Return) {
	if mock.DeviceGetModuleIdFunc == nil {
		panic("Interface.DeviceGetModuleIdFunc: method is nil but Interface.DeviceGetModuleId was just called")
	}
	callInfo := struct {
		Device nvml.Device
	}{
		Device: device,
	}
	mock.lockDeviceGetModuleId.Lock()
	mock.calls.DeviceGetModuleId = append(mock.calls.DeviceGetModuleId, callInfo)
	mock.lockDeviceGetModuleId.Unlock()
	return mock.DeviceGetModuleIdFunc(device)
}

// DeviceGetModuleIdCalls gets all the calls that were made to DeviceGetModuleId.
// Check the length with:
//
//	len(mockedInterface.DeviceGetModuleIdCalls())
func (mock *Interface) DeviceGetModuleIdCalls() []struct {
	Device nvml.Device
} {
	var calls []struct {
		Device nvml.Device
	}
	mock.lockDeviceGetModuleId.RLock()
	calls = mock.calls.DeviceGetModuleId
	mock.lockDeviceGetModuleId.RUnlock()
	return calls
}

// DeviceGetMultiGpuBoard calls DeviceGetMultiGpuBoardFunc.
func (mock *Interface) DeviceGetMultiGpuBoard(device nvml.Device) (int, nvml.Return) {
	if mock.DeviceGetMultiGpuBoardFunc == nil {
		panic("Interface.DeviceGetMultiGpuBoardFunc: method is nil but Interface.DeviceGetMultiGpuBoard was just called")
	}
	callInfo := struct {
		Device nvml.Device
	}{
		Device: device,
	}
	mock.lockDeviceGetMultiGpuBoard.Lock()
	mock.calls.DeviceGetMultiGpuBoard = append(mock.calls.DeviceGetMultiGpuBoard, callInfo)
	mock.lockDeviceGetMultiGpuBoard.Unlock()
	return mock.DeviceGetMultiGpuBoardFunc(device)
}

// DeviceGetMultiGpuBoardCalls gets all the calls that were made to DeviceGetMultiGpuBoard.
// Check the length with:
//
//	len(mockedInterface.DeviceGetMultiGpuBoardCalls())
func (mock *Interface) DeviceGetMultiGpuBoardCalls() []struct {
	Device nvml.Device
} {
	var calls []struct {
		Device nvml.Device
	}
	mock.lockDeviceGetMultiGpuBoard.RLock()
	calls = mock.calls.DeviceGetMultiGpuBoard
	mock.lockDeviceGetMultiGpuBoard.RUnlock()
	return calls
}

// DeviceGetName calls DeviceGetNameFunc.
func (mock *Interface) DeviceGetName(device nvml.Device) (string, nvml.Return) {
	if mock.DeviceGetNameFunc == nil {
		panic("Interface.DeviceGetNameFunc: method is nil but Interface.DeviceGetName was just called")
	}
	callInfo := struct {
		Device nvml.Device
	}{
		Device: device,
	}
	mock.lockDeviceGetName.Lock()
	mock.calls.DeviceGetName = append(mock.calls.DeviceGetName, callInfo)
	mock.lockDeviceGetName.Unlock()
	return mock.DeviceGetNameFunc(device)
}

// DeviceGetNameCalls gets all the calls that were made to DeviceGetName.
// Check the length with:
//
//	len(mockedInterface.DeviceGetNameCalls())
func (mock *Interface) DeviceGetNameCalls() []struct {
	Device nvml.Device
} {
	var calls []struct {
		Device nvml.Device
	}
	mock.lockDeviceGetName.RLock()
	calls = mock.calls.DeviceGetName
	mock.lockDeviceGetName.RUnlock()
	return calls
}

// DeviceGetNumFans calls DeviceGetNumFansFunc.
func (mock *Interface) DeviceGetNumFans(device nvml.Device) (int, nvml.Return) {
	if mock.DeviceGetNumFansFunc == nil {
		panic("Interface.DeviceGetNumFansFunc: method is nil but Interface.DeviceGetNumFans was just called")
	}
	callInfo := struct {
		Device nvml.Device
	}{
		Device: device,
	}
	mock.lockDeviceGetNumFans.Lock()
	mock.calls.DeviceGetNumFans = append(mock.calls.DeviceGetNumFans, callInfo)
	mock.lockDeviceGetNumFans.Unlock()
	return mock.DeviceGetNumFansFunc(device)
}

// DeviceGetNumFansCalls gets all the calls that were made to DeviceGetNumFans.
// Check the length with:
//
//	len(mockedInterface.DeviceGetNumFansCalls())
func (mock *Interface) DeviceGetNumFansCalls() []struct {
	Device nvml.Device
} {
	var calls []struct {
		Device nvml.Device
	}
	mock.lockDeviceGetNumFans.RLock()
	calls = mock.calls.DeviceGetNumFans
	mock.lockDeviceGetNumFans.RUnlock()
	return calls
}

// DeviceGetNumGpuCores calls DeviceGetNumGpuCoresFunc.
func (mock *Interface) DeviceGetNumGpuCores(device nvml.Device) (int, nvml.Return) {
	if mock.DeviceGetNumGpuCoresFunc == nil {
		panic("Interface.DeviceGetNumGpuCoresFunc: method is nil but Interface.DeviceGetNumGpuCores was just called")
	}
	callInfo := struct {
		Device nvml.Device
	}{
		Device: device,
	}
	mock.lockDeviceGetNumGpuCores.Lock()
	mock.calls.DeviceGetNumGpuCores = append(mock.calls.DeviceGetNumGpuCores, callInfo)
	mock.lockDeviceGetNumGpuCores.Unlock()
	return mock.DeviceGetNumGpuCoresFunc(device)
}

// DeviceGetNumGpuCoresCalls gets all the calls that were made to DeviceGetNumGpuCores.
// Check the length with:
//
//	len(mockedInterface.DeviceGetNumGpuCoresCalls())
func (mock *Interface) DeviceGetNumGpuCoresCalls() []struct {
	Device nvml.Device
} {
	var calls []struct {
		Device nvml.Device
	}
	mock.lockDeviceGetNumGpuCores.RLock()
	calls = mock.calls.DeviceGetNumGpuCores
	mock.lockDeviceGetNumGpuCores.RUnlock()
	return calls
}

// DeviceGetNumaNodeId calls DeviceGetNumaNodeIdFunc.
func (mock *Interface) DeviceGetNumaNodeId(device nvml.Device) (int, nvml.Return) {
	if mock.DeviceGetNumaNodeIdFunc == nil {
		panic("Interface.DeviceGetNumaNodeIdFunc: method is nil but Interface.DeviceGetNumaNodeId was just called")
	}
	callInfo := struct {
		Device nvml.Device
	}{
		Device: device,
	}
	mock.lockDeviceGetNumaNodeId.Lock()
	mock.calls.DeviceGetNumaNodeId = append(mock.calls.DeviceGetNumaNodeId, callInfo)
	mock.lockDeviceGetNumaNodeId.Unlock()
	return mock.DeviceGetNumaNodeIdFunc(device)
}

// DeviceGetNumaNodeIdCalls gets all the calls that were made to DeviceGetNumaNodeId.
// Check the length with:
//
//	len(mockedInterface.DeviceGetNumaNodeIdCalls())
func (mock *Interface) DeviceGetNumaNodeIdCalls() []struct {
	Device nvml.Device
} {
	var calls []struct {
		Device nvml.Device
	}
	mock.lockDeviceGetNumaNodeId.RLock()
	calls = mock.calls.DeviceGetNumaNodeId
	mock.lockDeviceGetNumaNodeId.RUnlock()
	return calls
}

// DeviceGetNvLinkCapability calls DeviceGetNvLinkCapabilityFunc.
func (mock *Interface) DeviceGetNvLinkCapability(device nvml.Device, n int, nvLinkCapability nvml.NvLinkCapability) (uint32, nvml.Return) {
	if mock.DeviceGetNvLinkCapabilityFunc == nil {
		panic("Interface.DeviceGetNvLinkCapabilityFunc: method is nil but Interface.DeviceGetNvLinkCapability was just called")
	}
	callInfo := struct {
		Device           nvml.Device
		N                int
		NvLinkCapability nvml.NvLinkCapability
	}{
		Device:           device,
		N:                n,
		NvLinkCapability: nvLinkCapability,
	}
	mock.lockDeviceGetNvLinkCapability.Lock()
	mock.calls.DeviceGetNvLinkCapability = append(mock.calls.DeviceGetNvLinkCapability, callInfo)
	mock.lockDeviceGetNvLinkCapability.Unlock()
	return mock.DeviceGetNvLinkCapabilityFunc(device, n, nvLinkCapability)
}

// DeviceGetNvLinkCapabilityCalls gets all the calls that were made to DeviceGetNvLinkCapability.
// Check the length with:
//
//	len(mockedInterface.DeviceGetNvLinkCapabilityCalls())
func (mock *Interface) DeviceGetNvLinkCapabilityCalls() []struct {
	Device           nvml.Device
	N                int
	NvLinkCapability nvml.NvLinkCapability
} {
	var calls []struct {
		Device           nvml.Device
		N                int
		NvLinkCapability nvml.NvLinkCapability
	}
	mock.lockDeviceGetNvLinkCapability.RLock()
	calls = mock.calls.DeviceGetNvLinkCapability
	mock.lockDeviceGetNvLinkCapability.RUnlock()
	return calls
}

// DeviceGetNvLinkErrorCounter calls DeviceGetNvLinkErrorCounterFunc.
func (mock *Interface) DeviceGetNvLinkErrorCounter(device nvml.Device, n int, nvLinkErrorCounter nvml.NvLinkErrorCounter) (uint64, nvml.Return) {
	if mock.DeviceGetNvLinkErrorCounterFunc == nil {
		panic("Interface.DeviceGetNvLinkErrorCounterFunc: method is nil but Interface.DeviceGetNvLinkErrorCounter was just called")
	}
	callInfo := struct {
		Device             nvml.Device
		N                  int
		NvLinkErrorCounter nvml.NvLinkErrorCounter
	}{
		Device:             device,
		N:                  n,
		NvLinkErrorCounter: nvLinkErrorCounter,
	}
	mock.lockDeviceGetNvLinkErrorCounter.Lock()
	mock.calls.DeviceGetNvLinkErrorCounter = append(mock.calls.DeviceGetNvLinkErrorCounter, callInfo)
	mock.lockDeviceGetNvLinkErrorCounter.Unlock()
	return mock.DeviceGetNvLinkErrorCounterFunc(device, n, nvLinkErrorCounter)
}

// DeviceGetNvLinkErrorCounterCalls gets all the calls that were made to DeviceGetNvLinkErrorCounter.
// Check the length with:
//
//	len(mockedInterface.DeviceGetNvLinkErrorCounterCalls())
func (mock *Interface) DeviceGetNvLinkErrorCounterCalls() []struct {
	Device             nvml.Device
	N                  int
	NvLinkErrorCounter nvml.NvLinkErrorCounter
} {
	var calls []struct {
		Device             nvml.Device
		N                  int
		NvLinkErrorCounter nvml.NvLinkErrorCounter
	}
	mock.lockDeviceGetNvLinkErrorCounter.RLock()
	calls = mock.calls.DeviceGetNvLinkErrorCounter
	mock.lockDeviceGetNvLinkErrorCounter.RUnlock()
	return calls
}

// DeviceGetNvLinkInfo calls DeviceGetNvLinkInfoFunc.
func (mock *Interface) DeviceGetNvLinkInfo(device nvml.Device) nvml.NvLinkInfoHandler {
	if mock.DeviceGetNvLinkInfoFunc == nil {
		panic("Interface.DeviceGetNvLinkInfoFunc: method is nil but Interface.DeviceGetNvLinkInfo was just called")
	}
	callInfo := struct {
		Device nvml.Device
	}{
		Device: device,
	}
	mock.lockDeviceGetNvLinkInfo.Lock()
	mock.calls.DeviceGetNvLinkInfo = append(mock.calls.DeviceGetNvLinkInfo, callInfo)
	mock.lockDeviceGetNvLinkInfo.Unlock()
	return mock.DeviceGetNvLinkInfoFunc(device)
}

// DeviceGetNvLinkInfoCalls gets all the calls that were made to DeviceGetNvLinkInfo.
// Check the length with:
//
//	len(mockedInterface.DeviceGetNvLinkInfoCalls())
func (mock *Interface) DeviceGetNvLinkInfoCalls() []struct {
	Device nvml.Device
} {
	var calls []struct {
		Device nvml.Device
	}
	mock.lockDeviceGetNvLinkInfo.RLock()
	calls = mock.calls.DeviceGetNvLinkInfo
	mock.lockDeviceGetNvLinkInfo.RUnlock()
	return calls
}

// DeviceGetNvLinkRemoteDeviceType calls DeviceGetNvLinkRemoteDeviceTypeFunc.
func (mock *Interface) DeviceGetNvLinkRemoteDeviceType(device nvml.Device, n int) (nvml.IntNvLinkDeviceType, nvml.Return) {
	if mock.DeviceGetNvLinkRemoteDeviceTypeFunc == nil {
		panic("Interface.DeviceGetNvLinkRemoteDeviceTypeFunc: method is nil but Interface.DeviceGetNvLinkRemoteDeviceType was just called")
	}
	callInfo := struct {
		Device nvml.Device
		N      int
	}{
		Device: device,
		N:      n,
	}
	mock.lockDeviceGetNvLinkRemoteDeviceType.Lock()
	mock.calls.DeviceGetNvLinkRemoteDeviceType = append(mock.calls.DeviceGetNvLinkRemoteDeviceType, callInfo)
	mock.lockDeviceGetNvLinkRemoteDeviceType.Unlock()
	return mock.DeviceGetNvLinkRemoteDeviceTypeFunc(device, n)
}

// DeviceGetNvLinkRemoteDeviceTypeCalls gets all the calls that were made to DeviceGetNvLinkRemoteDeviceType.
// Check the length with:
//
//	len(mockedInterface.DeviceGetNvLinkRemoteDeviceTypeCalls())
func (mock *Interface) DeviceGetNvLinkRemoteDeviceTypeCalls() []struct {
	Device nvml.Device
	N      int
} {
	var calls []struct {
		Device nvml.Device
		N      int
	}
	mock.lockDeviceGetNvLinkRemoteDeviceType.RLock()
	calls = mock.calls.DeviceGetNvLinkRemoteDeviceType
	mock.lockDeviceGetNvLinkRemoteDeviceType.RUnlock()
	return calls
}

// DeviceGetNvLinkRemotePciInfo calls DeviceGetNvLinkRemotePciInfoFunc.
func (mock *Interface) DeviceGetNvLinkRemotePciInfo(device nvml.Device, n int) (nvml.PciInfo, nvml.Return) {
	if mock.DeviceGetNvLinkRemotePciInfoFunc == nil {
		panic("Interface.DeviceGetNvLinkRemotePciInfoFunc: method is nil but Interface.DeviceGetNvLinkRemotePciInfo was just called")
	}
	callInfo := struct {
		Device nvml.Device
		N      int
	}{
		Device: device,
		N:      n,
	}
	mock.lockDeviceGetNvLinkRemotePciInfo.Lock()
	mock.calls.DeviceGetNvLinkRemotePciInfo = append(mock.calls.DeviceGetNvLinkRemotePciInfo, callInfo)
	mock.lockDeviceGetNvLinkRemotePciInfo.Unlock()
	return mock.DeviceGetNvLinkRemotePciInfoFunc(device, n)
}

// DeviceGetNvLinkRemotePciInfoCalls gets all the calls that were made to DeviceGetNvLinkRemotePciInfo.
// Check the length with:
//
//	len(mockedInterface.DeviceGetNvLinkRemotePciInfoCalls())
func (mock *Interface) DeviceGetNvLinkRemotePciInfoCalls() []struct {
	Device nvml.Device
	N      int
} {
	var calls []struct {
		Device nvml.Device
		N      int
	}
	mock.lockDeviceGetNvLinkRemotePciInfo.RLock()
	calls = mock.calls.DeviceGetNvLinkRemotePciInfo
	mock.lockDeviceGetNvLinkRemotePciInfo.RUnlock()
	return calls
}

// DeviceGetNvLinkState calls DeviceGetNvLinkStateFunc.
func (mock *Interface) DeviceGetNvLinkState(device nvml.Device, n int) (nvml.EnableState, nvml.Return) {
	if mock.DeviceGetNvLinkStateFunc == nil {
		panic("Interface.DeviceGetNvLinkStateFunc: method is nil but Interface.DeviceGetNvLinkState was just called")
	}
	callInfo := struct {
		Device nvml.Device
		N      int
	}{
		Device: device,
		N:      n,
	}
	mock.lockDeviceGetNvLinkState.Lock()
	mock.calls.DeviceGetNvLinkState = append(mock.calls.DeviceGetNvLinkState, callInfo)
	mock.lockDeviceGetNvLinkState.Unlock()
	return mock.DeviceGetNvLinkStateFunc(device, n)
}

// DeviceGetNvLinkStateCalls gets all the calls that were made to DeviceGetNvLinkState.
// Check the length with:
//
//	len(mockedInterface.DeviceGetNvLinkStateCalls())
func (mock *Interface) DeviceGetNvLinkStateCalls() []struct {
	Device nvml.Device
	N      int
} {
	var calls []struct {
		Device nvml.Device
		N      int
	}
	mock.lockDeviceGetNvLinkState.RLock()
	calls = mock.calls.DeviceGetNvLinkState
	mock.lockDeviceGetNvLinkState.RUnlock()
	return calls
}

// DeviceGetNvLinkUtilizationControl calls DeviceGetNvLinkUtilizationControlFunc.
func (mock *Interface) DeviceGetNvLinkUtilizationControl(device nvml.Device, n1 int, n2 int) (nvml.NvLinkUtilizationControl, nvml.Return) {
	if mock.DeviceGetNvLinkUtilizationControlFunc == nil {
		panic("Interface.DeviceGetNvLinkUtilizationControlFunc: method is nil but Interface.DeviceGetNvLinkUtilizationControl was just called")
	}
	callInfo := struct {
		Device nvml.Device
		N1     int
		N2     int
	}{
		Device: device,
		N1:     n1,
		N2:     n2,
	}
	mock.lockDeviceGetNvLinkUtilizationControl.Lock()
	mock.calls.DeviceGetNvLinkUtilizationControl = append(mock.calls.DeviceGetNvLinkUtilizationControl, callInfo)
	mock.lockDeviceGetNvLinkUtilizationControl.Unlock()
	return mock.DeviceGetNvLinkUtilizationControlFunc(device, n1, n2)
}

// DeviceGetNvLinkUtilizationControlCalls gets all the calls that were made to DeviceGetNvLinkUtilizationControl.
// Check the length with:
//
//	len(mockedInterface.DeviceGetNvLinkUtilizationControlCalls())
func (mock *Interface) DeviceGetNvLinkUtilizationControlCalls() []struct {
	Device nvml.Device
	N1     int
	N2     int
} {
	var calls []struct {
		Device nvml.Device
		N1     int
		N2     int
	}
	mock.lockDeviceGetNvLinkUtilizationControl.RLock()
	calls = mock.calls.DeviceGetNvLinkUtilizationControl
	mock.lockDeviceGetNvLinkUtilizationControl.RUnlock()
	return calls
}

// DeviceGetNvLinkUtilizationCounter calls DeviceGetNvLinkUtilizationCounterFunc.
func (mock *Interface) DeviceGetNvLinkUtilizationCounter(device nvml.Device, n1 int, n2 int) (uint64, uint64, nvml.Return) {
	if mock.DeviceGetNvLinkUtilizationCounterFunc == nil {
		panic("Interface.DeviceGetNvLinkUtilizationCounterFunc: method is nil but Interface.DeviceGetNvLinkUtilizationCounter was just called")
	}
	callInfo := struct {
		Device nvml.Device
		N1     int
		N2     int
	}{
		Device: device,
		N1:     n1,
		N2:     n2,
	}
	mock.lockDeviceGetNvLinkUtilizationCounter.Lock()
	mock.calls.DeviceGetNvLinkUtilizationCounter = append(mock.calls.DeviceGetNvLinkUtilizationCounter, callInfo)
	mock.lockDeviceGetNvLinkUtilizationCounter.Unlock()
	return mock.DeviceGetNvLinkUtilizationCounterFunc(device, n1, n2)
}

// DeviceGetNvLinkUtilizationCounterCalls gets all the calls that were made to DeviceGetNvLinkUtilizationCounter.
// Check the length with:
//
//	len(mockedInterface.DeviceGetNvLinkUtilizationCounterCalls())
func (mock *Interface) DeviceGetNvLinkUtilizationCounterCalls() []struct {
	Device nvml.Device
	N1     int
	N2     int
} {
	var calls []struct {
		Device nvml.Device
		N1     int
		N2     int
	}
	mock.lockDeviceGetNvLinkUtilizationCounter.RLock()
	calls = mock.calls.DeviceGetNvLinkUtilizationCounter
	mock.lockDeviceGetNvLinkUtilizationCounter.RUnlock()
	return calls
}

// DeviceGetNvLinkVersion calls DeviceGetNvLinkVersionFunc.
func (mock *Interface) DeviceGetNvLinkVersion(device nvml.Device, n int) (uint32, nvml.Return) {
	if mock.DeviceGetNvLinkVersionFunc == nil {
		panic("Interface.DeviceGetNvLinkVersionFunc: method is nil but Interface.DeviceGetNvLinkVersion was just called")
	}
	callInfo := struct {
		Device nvml.Device
		N      int
	}{
		Device: device,
		N:      n,
	}
	mock.lockDeviceGetNvLinkVersion.Lock()
	mock.calls.DeviceGetNvLinkVersion = append(mock.calls.DeviceGetNvLinkVersion, callInfo)
	mock.lockDeviceGetNvLinkVersion.Unlock()
	return mock.DeviceGetNvLinkVersionFunc(device, n)
}

// DeviceGetNvLinkVersionCalls gets all the calls that were made to DeviceGetNvLinkVersion.
// Check the length with:
//
//	len(mockedInterface.DeviceGetNvLinkVersionCalls())
func (mock *Interface) DeviceGetNvLinkVersionCalls() []struct {
	Device nvml.Device
	N      int
} {
	var calls []struct {
		Device nvml.Device
		N      int
	}
	mock.lockDeviceGetNvLinkVersion.RLock()
	calls = mock.calls.DeviceGetNvLinkVersion
	mock.lockDeviceGetNvLinkVersion.RUnlock()
	return calls
}

// DeviceGetNvlinkBwMode calls DeviceGetNvlinkBwModeFunc.
func (mock *Interface) DeviceGetNvlinkBwMode(device nvml.Device) (nvml.NvlinkGetBwMode, nvml.Return) {
	if mock.DeviceGetNvlinkBwModeFunc == nil {
		panic("Interface.DeviceGetNvlinkBwModeFunc: method is nil but Interface.DeviceGetNvlinkBwMode was just called")
	}
	callInfo := struct {
		Device nvml.Device
	}{
		Device: device,
	}
	mock.lockDeviceGetNvlinkBwMode.Lock()
	mock.calls.DeviceGetNvlinkBwMode = append(mock.calls.DeviceGetNvlinkBwMode, callInfo)
	mock.lockDeviceGetNvlinkBwMode.Unlock()
	return mock.DeviceGetNvlinkBwModeFunc(device)
}

// DeviceGetNvlinkBwModeCalls gets all the calls that were made to DeviceGetNvlinkBwMode.
// Check the length with:
//
//	len(mockedInterface.DeviceGetNvlinkBwModeCalls())
func (mock *Interface) DeviceGetNvlinkBwModeCalls() []struct {
	Device nvml.Device
} {
	var calls []struct {
		Device nvml.Device
	}
	mock.lockDeviceGetNvlinkBwMode.RLock()
	calls = mock.calls.DeviceGetNvlinkBwMode
	mock.lockDeviceGetNvlinkBwMode.RUnlock()
	return calls
}

// DeviceGetNvlinkSupportedBwModes calls DeviceGetNvlinkSupportedBwModesFunc.
func (mock *Interface) DeviceGetNvlinkSupportedBwModes(device nvml.Device) (nvml.NvlinkSupportedBwModes, nvml.Return) {
	if mock.DeviceGetNvlinkSupportedBwModesFunc == nil {
		panic("Interface.DeviceGetNvlinkSupportedBwModesFunc: method is nil but Interface.DeviceGetNvlinkSupportedBwModes was just called")
	}
	callInfo := struct {
		Device nvml.Device
	}{
		Device: device,
	}
	mock.lockDeviceGetNvlinkSupportedBwModes.Lock()
	mock.calls.DeviceGetNvlinkSupportedBwModes = append(mock.calls.DeviceGetNvlinkSupportedBwModes, callInfo)
	mock.lockDeviceGetNvlinkSupportedBwModes.Unlock()
	return mock.DeviceGetNvlinkSupportedBwModesFunc(device)
}

// DeviceGetNvlinkSupportedBwModesCalls gets all the calls that were made to DeviceGetNvlinkSupportedBwModes.
// Check the length with:
//
//	len(mockedInterface.DeviceGetNvlinkSupportedBwModesCalls())
func (mock *Interface) DeviceGetNvlinkSupportedBwModesCalls() []struct {
	Device nvml.Device
} {
	var calls []struct {
		Device nvml.Device
	}
	mock.lockDeviceGetNvlinkSupportedBwModes.RLock()
	calls = mock.calls.DeviceGetNvlinkSupportedBwModes
	mock.lockDeviceGetNvlinkSupportedBwModes.RUnlock()
	return calls
}

// DeviceGetOfaUtilization calls DeviceGetOfaUtilizationFunc.
func (mock *Interface) DeviceGetOfaUtilization(device nvml.Device) (uint32, uint32, nvml.Return) {
	if mock.DeviceGetOfaUtilizationFunc == nil {
		panic("Interface.DeviceGetOfaUtilizationFunc: method is nil but Interface.DeviceGetOfaUtilization was just called")
	}
	callInfo := struct {
		Device nvml.Device
	}{
		Device: device,
	}
	mock.lockDeviceGetOfaUtilization.Lock()
	mock.calls.DeviceGetOfaUtilization = append(mock.calls.DeviceGetOfaUtilization, callInfo)
	mock.lockDeviceGetOfaUtilization.Unlock()
	return mock.DeviceGetOfaUtilizationFunc(device)
}

// DeviceGetOfaUtilizationCalls gets all the calls that were made to DeviceGetOfaUtilization.
// Check the length with:
//
//	len(mockedInterface.DeviceGetOfaUtilizationCalls())
func (mock *Interface) DeviceGetOfaUtilizationCalls() []struct {
	Device nvml.Device
} {
	var calls []struct {
		Device nvml.Device
	}
	mock.lockDeviceGetOfaUtilization.RLock()
	calls = mock.calls.DeviceGetOfaUtilization
	mock.lockDeviceGetOfaUtilization.RUnlock()
	return calls
}

// DeviceGetP2PStatus calls DeviceGetP2PStatusFunc.
func (mock *Interface) DeviceGetP2PStatus(device1 nvml.Device, device2 nvml.Device, gpuP2PCapsIndex nvml.GpuP2PCapsIndex) (nvml.GpuP2PStatus, nvml.Return) {
	if mock.DeviceGetP2PStatusFunc == nil {
		panic("Interface.DeviceGetP2PStatusFunc: method is nil but Interface.DeviceGetP2PStatus was just called")
	}
	callInfo := struct {
		Device1         nvml.Device
		Device2         nvml.Device
		GpuP2PCapsIndex nvml.GpuP2PCapsIndex
	}{
		Device1:         device1,
		Device2:         device2,
		GpuP2PCapsIndex: gpuP2PCapsIndex,
	}
	mock.lockDeviceGetP2PStatus.Lock()
	mock.calls.DeviceGetP2PStatus = append(mock.calls.DeviceGetP2PStatus, callInfo)
	mock.lockDeviceGetP2PStatus.Unlock()
	return mock.DeviceGetP2PStatusFunc(device1, device2, gpuP2PCapsIndex)
}

// DeviceGetP2PStatusCalls gets all the calls that were made to DeviceGetP2PStatus.
// Check the length with:
//
//	len(mockedInterface.DeviceGetP2PStatusCalls())
func (mock *Interface) DeviceGetP2PStatusCalls() []struct {
	Device1         nvml.Device
	Device2         nvml.Device
	GpuP2PCapsIndex nvml.GpuP2PCapsIndex
} {
	var calls []struct {
		Device1         nvml.Device
		Device2         nvml.Device
		GpuP2PCapsIndex nvml.GpuP2PCapsIndex
	}
	mock.lockDeviceGetP2PStatus.RLock()
	calls = mock.calls.DeviceGetP2PStatus
	mock.lockDeviceGetP2PStatus.RUnlock()
	return calls
}

// DeviceGetPciInfo calls DeviceGetPciInfoFunc.
func (mock *Interface) DeviceGetPciInfo(device nvml.Device) (nvml.PciInfo, nvml.Return) {
	if mock.DeviceGetPciInfoFunc == nil {
		panic("Interface.DeviceGetPciInfoFunc: method is nil but Interface.DeviceGetPciInfo was just called")
	}
	callInfo := struct {
		Device nvml.Device
	}{
		Device: device,
	}
	mock.lockDeviceGetPciInfo.Lock()
	mock.calls.DeviceGetPciInfo = append(mock.calls.DeviceGetPciInfo, callInfo)
	mock.lockDeviceGetPciInfo.Unlock()
	return mock.DeviceGetPciInfoFunc(device)
}

// DeviceGetPciInfoCalls gets all the calls that were made to DeviceGetPciInfo.
// Check the length with:
//
//	len(mockedInterface.DeviceGetPciInfoCalls())
func (mock *Interface) DeviceGetPciInfoCalls() []struct {
	Device nvml.Device
} {
	var calls []struct {
		Device nvml.Device
	}
	mock.lockDeviceGetPciInfo.RLock()
	calls = mock.calls.DeviceGetPciInfo
	mock.lockDeviceGetPciInfo.RUnlock()
	return calls
}

// DeviceGetPciInfoExt calls DeviceGetPciInfoExtFunc.
func (mock *Interface) DeviceGetPciInfoExt(device nvml.Device) (nvml.PciInfoExt, nvml.Return) {
	if mock.DeviceGetPciInfoExtFunc == nil {
		panic("Interface.DeviceGetPciInfoExtFunc: method is nil but Interface.DeviceGetPciInfoExt was just called")
	}
	callInfo := struct {
		Device nvml.Device
	}{
		Device: device,
	}
	mock.lockDeviceGetPciInfoExt.Lock()
	mock.calls.DeviceGetPciInfoExt = append(mock.calls.DeviceGetPciInfoExt, callInfo)
	mock.lockDeviceGetPciInfoExt.Unlock()
	return mock.DeviceGetPciInfoExtFunc(device)
}

// DeviceGetPciInfoExtCalls gets all the calls that were made to DeviceGetPciInfoExt.
// Check the length with:
//
//	len(mockedInterface.DeviceGetPciInfoExtCalls())
func (mock *Interface) DeviceGetPciInfoExtCalls() []struct {
	Device nvml.Device
} {
	var calls []struct {
		Device nvml.Device
	}
	mock.lockDeviceGetPciInfoExt.RLock()
	calls = mock.calls.DeviceGetPciInfoExt
	mock.lockDeviceGetPciInfoExt.RUnlock()
	return calls
}

// DeviceGetPcieLinkMaxSpeed calls DeviceGetPcieLinkMaxSpeedFunc.
func (mock *Interface) DeviceGetPcieLinkMaxSpeed(device nvml.Device) (uint32, nvml.Return) {
	if mock.DeviceGetPcieLinkMaxSpeedFunc == nil {
		panic("Interface.DeviceGetPcieLinkMaxSpeedFunc: method is nil but Interface.DeviceGetPcieLinkMaxSpeed was just called")
	}
	callInfo := struct {
		Device nvml.Device
	}{
		Device: device,
	}
	mock.lockDeviceGetPcieLinkMaxSpeed.Lock()
	mock.calls.DeviceGetPcieLinkMaxSpeed = append(mock.calls.DeviceGetPcieLinkMaxSpeed, callInfo)
	mock.lockDeviceGetPcieLinkMaxSpeed.Unlock()
	return mock.DeviceGetPcieLinkMaxSpeedFunc(device)
}

// DeviceGetPcieLinkMaxSpeedCalls gets all the calls that were made to DeviceGetPcieLinkMaxSpeed.
// Check the length with:
//
//	len(mockedInterface.DeviceGetPcieLinkMaxSpeedCalls())
func (mock *Interface) DeviceGetPcieLinkMaxSpeedCalls() []struct {
	Device nvml.Device
} {
	var calls []struct {
		Device nvml.Device
	}
	mock.lockDeviceGetPcieLinkMaxSpeed.RLock()
	calls = mock.calls.DeviceGetPcieLinkMaxSpeed
	mock.lockDeviceGetPcieLinkMaxSpeed.RUnlock()
	return calls
}

// DeviceGetPcieReplayCounter calls DeviceGetPcieReplayCounterFunc.
func (mock *Interface) DeviceGetPcieReplayCounter(device nvml.Device) (int, nvml.Return) {
	if mock.DeviceGetPcieReplayCounterFunc == nil {
		panic("Interface.DeviceGetPcieReplayCounterFunc: method is nil but Interface.DeviceGetPcieReplayCounter was just called")
	}
	callInfo := struct {
		Device nvml.Device
	}{
		Device: device,
	}
	mock.lockDeviceGetPcieReplayCounter.Lock()
	mock.calls.DeviceGetPcieReplayCounter = append(mock.calls.DeviceGetPcieReplayCounter, callInfo)
	mock.lockDeviceGetPcieReplayCounter.Unlock()
	return mock.DeviceGetPcieReplayCounterFunc(device)
}

// DeviceGetPcieReplayCounterCalls gets all the calls that were made to DeviceGetPcieReplayCounter.
// Check the length with:
//
//	len(mockedInterface.DeviceGetPcieReplayCounterCalls())
func (mock *Interface) DeviceGetPcieReplayCounterCalls() []struct {
	Device nvml.Device
} {
	var calls []struct {
		Device nvml.Device
	}
	mock.lockDeviceGetPcieReplayCounter.RLock()
	calls = mock.calls.DeviceGetPcieReplayCounter
	mock.lockDeviceGetPcieReplayCounter.RUnlock()
	return calls
}

// DeviceGetPcieSpeed calls DeviceGetPcieSpeedFunc.
func (mock *Interface) DeviceGetPcieSpeed(device nvml.Device) (int, nvml.Return) {
	if mock.DeviceGetPcieSpeedFunc == nil {
		panic("Interface.DeviceGetPcieSpeedFunc: method is nil but Interface.DeviceGetPcieSpeed was just called")
	}
	callInfo := struct {
		Device nvml.Device
	}{
		Device: device,
	}
	mock.lockDeviceGetPcieSpeed.Lock()
	mock.calls.DeviceGetPcieSpeed = append(mock.calls.DeviceGetPcieSpeed, callInfo)
	mock.lockDeviceGetPcieSpeed.Unlock()
	return mock.DeviceGetPcieSpeedFunc(device)
}

// DeviceGetPcieSpeedCalls gets all the calls that were made to DeviceGetPcieSpeed.
// Check the length with:
//
//	len(mockedInterface.DeviceGetPcieSpeedCalls())
func (mock *Interface) DeviceGetPcieSpeedCalls() []struct {
	Device nvml.Device
} {
	var calls []struct {
		Device nvml.Device
	}
	mock.lockDeviceGetPcieSpeed.RLock()
	calls = mock.calls.DeviceGetPcieSpeed
	mock.lockDeviceGetPcieSpeed.RUnlock()
	return calls
}

// DeviceGetPcieThroughput calls DeviceGetPcieThroughputFunc.
func (mock *Interface) DeviceGetPcieThroughput(device nvml.Device, pcieUtilCounter nvml.PcieUtilCounter) (uint32, nvml.Return) {
	if mock.DeviceGetPcieThroughputFunc == nil {
		panic("Interface.DeviceGetPcieThroughputFunc: method is nil but Interface.DeviceGetPcieThroughput was just called")
	}
	callInfo := struct {
		Device          nvml.Device
		PcieUtilCounter nvml.PcieUtilCounter
	}{
		Device:          device,
		PcieUtilCounter: pcieUtilCounter,
	}
	mock.lockDeviceGetPcieThroughput.Lock()
	mock.calls.DeviceGetPcieThroughput = append(mock.calls.DeviceGetPcieThroughput, callInfo)
	mock.lockDeviceGetPcieThroughput.Unlock()
	return mock.DeviceGetPcieThroughputFunc(device, pcieUtilCounter)
}

// DeviceGetPcieThroughputCalls gets all the calls that were made to DeviceGetPcieThroughput.
// Check the length with:
//
//	len(mockedInterface.DeviceGetPcieThroughputCalls())
func (mock *Interface) DeviceGetPcieThroughputCalls() []struct {
	Device          nvml.Device
	PcieUtilCounter nvml.PcieUtilCounter
} {
	var calls []struct {
		Device          nvml.Device
		PcieUtilCounter nvml.PcieUtilCounter
	}
	mock.lockDeviceGetPcieThroughput.RLock()
	calls = mock.calls.DeviceGetPcieThroughput
	mock.lockDeviceGetPcieThroughput.RUnlock()
	return calls
}

// DeviceGetPdi calls DeviceGetPdiFunc.
func (mock *Interface) DeviceGetPdi(device nvml.Device) (nvml.Pdi, nvml.Return) {
	if mock.DeviceGetPdiFunc == nil {
		panic("Interface.DeviceGetPdiFunc: method is nil but Interface.DeviceGetPdi was just called")
	}
	callInfo := struct {
		Device nvml.Device
	}{
		Device: device,
	}
	mock.lockDeviceGetPdi.Lock()
	mock.calls.DeviceGetPdi = append(mock.calls.DeviceGetPdi, callInfo)
	mock.lockDeviceGetPdi.Unlock()
	return mock.DeviceGetPdiFunc(device)
}

// DeviceGetPdiCalls gets all the calls that were made to DeviceGetPdi.
// Check the length with:
//
//	len(mockedInterface.DeviceGetPdiCalls())
func (mock *Interface) DeviceGetPdiCalls() []struct {
	Device nvml.Device
} {
	var calls []struct {
		Device nvml.Device
	}
	mock.lockDeviceGetPdi.RLock()
	calls = mock.calls.DeviceGetPdi
	mock.lockDeviceGetPdi.RUnlock()
	return calls
}

// DeviceGetPerformanceModes calls DeviceGetPerformanceModesFunc.
func (mock *Interface) DeviceGetPerformanceModes(device nvml.Device) (nvml.DevicePerfModes, nvml.Return) {
	if mock.DeviceGetPerformanceModesFunc == nil {
		panic("Interface.DeviceGetPerformanceModesFunc: method is nil but Interface.DeviceGetPerformanceModes was just called")
	}
	callInfo := struct {
		Device nvml.Device
	}{
		Device: device,
	}
	mock.lockDeviceGetPerformanceModes.Lock()
	mock.calls.DeviceGetPerformanceModes = append(mock.calls.DeviceGetPerformanceModes, callInfo)
	mock.lockDeviceGetPerformanceModes.Unlock()
	return mock.DeviceGetPerformanceModesFunc(device)
}

// DeviceGetPerformanceModesCalls gets all the calls that were made to DeviceGetPerformanceModes.
// Check the length with:
//
//	len(mockedInterface.DeviceGetPerformanceModesCalls())
func (mock *Interface) DeviceGetPerformanceModesCalls() []struct {
	Device nvml.Device
} {
	var calls []struct {
		Device nvml.Device
	}
	mock.lockDeviceGetPerformanceModes.RLock()
	calls = mock.calls.DeviceGetPerformanceModes
	mock.lockDeviceGetPerformanceModes.RUnlock()
	return calls
}

// DeviceGetPerformanceState calls DeviceGetPerformanceStateFunc.
func (mock *Interface) DeviceGetPerformanceState(device nvml.Device) (nvml.Pstates, nvml.Return) {
	if mock.DeviceGetPerformanceStateFunc == nil {
		panic("Interface.DeviceGetPerformanceStateFunc: method is nil but Interface.DeviceGetPerformanceState was just called")
	}
	callInfo := struct {
		Device nvml.Device
	}{
		Device: device,
	}
	mock.lockDeviceGetPerformanceState.Lock()
	mock.calls.DeviceGetPerformanceState = append(mock.calls.DeviceGetPerformanceState, callInfo)
	mock.lockDeviceGetPerformanceState.Unlock()
	return mock.DeviceGetPerformanceStateFunc(device)
}

// DeviceGetPerformanceStateCalls gets all the calls that were made to DeviceGetPerformanceState.
// Check the length with:
//
//	len(mockedInterface.DeviceGetPerformanceStateCalls())
func (mock *Interface) DeviceGetPerformanceStateCalls() []struct {
	Device nvml.Device
} {
	var calls []struct {
		Device nvml.Device
	}
	mock.lockDeviceGetPerformanceState.RLock()
	calls = mock.calls.DeviceGetPerformanceState
	mock.lockDeviceGetPerformanceState.RUnlock()
	return calls
}

// DeviceGetPersistenceMode calls DeviceGetPersistenceModeFunc.
func (mock *Interface) DeviceGetPersistenceMode(device nvml.Device) (nvml.EnableState, nvml.Return) {
	if mock.DeviceGetPersistenceModeFunc == nil {
		panic("Interface.DeviceGetPersistenceModeFunc: method is nil but Interface.DeviceGetPersistenceMode was just called")
	}
	callInfo := struct {
		Device nvml.Device
	}{
		Device: device,
	}
	mock.lockDeviceGetPersistenceMode.Lock()
	mock.calls.DeviceGetPersistenceMode = append(mock.calls.DeviceGetPersistenceMode, callInfo)
	mock.lockDeviceGetPersistenceMode.Unlock()
	return mock.DeviceGetPersistenceModeFunc(device)
}

// DeviceGetPersistenceModeCalls gets all the calls that were made to DeviceGetPersistenceMode.
// Check the length with:
//
//	len(mockedInterface.DeviceGetPersistenceModeCalls())
func (mock *Interface) DeviceGetPersistenceModeCalls() []struct {
	Device nvml.Device
} {
	var calls []struct {
		Device nvml.Device
	}
	mock.lockDeviceGetPersistenceMode.RLock()
	calls = mock.calls.DeviceGetPersistenceMode
	mock.lockDeviceGetPersistenceMode.RUnlock()
	return calls
}

// DeviceGetPgpuMetadataString calls DeviceGetPgpuMetadataStringFunc.
func (mock *Interface) DeviceGetPgpuMetadataString(device nvml.Device) (string, nvml.Return) {
	if mock.DeviceGetPgpuMetadataStringFunc == nil {
		panic("Interface.DeviceGetPgpuMetadataStringFunc: method is nil but Interface.DeviceGetPgpuMetadataString was just called")
	}
	callInfo := struct {
		Device nvml.Device
	}{
		Device: device,
	}
	mock.lockDeviceGetPgpuMetadataString.Lock()
	mock.calls.DeviceGetPgpuMetadataString = append(mock.calls.DeviceGetPgpuMetadataString, callInfo)
	mock.lockDeviceGetPgpuMetadataString.Unlock()
	return mock.DeviceGetPgpuMetadataStringFunc(device)
}

// DeviceGetPgpuMetadataStringCalls gets all the calls that were made to DeviceGetPgpuMetadataString.
// Check the length with:
//
//	len(mockedInterface.DeviceGetPgpuMetadataStringCalls())
func (mock *Interface) DeviceGetPgpuMetadataStringCalls() []struct {
	Device nvml.Device
} {
	var calls []struct {
		Device nvml.Device
	}
	mock.lockDeviceGetPgpuMetadataString.RLock()
	calls = mock.calls.DeviceGetPgpuMetadataString
	mock.lockDeviceGetPgpuMetadataString.RUnlock()
	return calls
}

// DeviceGetPlatformInfo calls DeviceGetPlatformInfoFunc.
func (mock *Interface) DeviceGetPlatformInfo(device nvml.Device) (nvml.PlatformInfo, nvml.Return) {
	if mock.DeviceGetPlatformInfoFunc == nil {
		panic("Interface.DeviceGetPlatformInfoFunc: method is nil but Interface.DeviceGetPlatformInfo was just called")
	}
	callInfo := struct {
		Device nvml.Device
	}{
		Device: device,
	}
	mock.lockDeviceGetPlatformInfo.Lock()
	mock.calls.DeviceGetPlatformInfo = append(mock.calls.DeviceGetPlatformInfo, callInfo)
	mock.lockDeviceGetPlatformInfo.Unlock()
	return mock.DeviceGetPlatformInfoFunc(device)
}

// DeviceGetPlatformInfoCalls gets all the calls that were made to DeviceGetPlatformInfo.
// Check the length with:
//
//	len(mockedInterface.DeviceGetPlatformInfoCalls())
func (mock *Interface) DeviceGetPlatformInfoCalls() []struct {
	Device nvml.Device
} {
	var calls []struct {
		Device nvml.Device
	}
	mock.lockDeviceGetPlatformInfo.RLock()
	calls = mock.calls.DeviceGetPlatformInfo
	mock.lockDeviceGetPlatformInfo.RUnlock()
	return calls
}

// DeviceGetPowerManagementDefaultLimit calls DeviceGetPowerManagementDefaultLimitFunc.
func (mock *Interface) DeviceGetPowerManagementDefaultLimit(device nvml.Device) (uint32, nvml.Return) {
	if mock.DeviceGetPowerManagementDefaultLimitFunc == nil {
		panic("Interface.DeviceGetPowerManagementDefaultLimitFunc: method is nil but Interface.DeviceGetPowerManagementDefaultLimit was just called")
	}
	callInfo := struct {
		Device nvml.Device
	}{
		Device: device,
	}
	mock.lockDeviceGetPowerManagementDefaultLimit.Lock()
	mock.calls.DeviceGetPowerManagementDefaultLimit = append(mock.calls.DeviceGetPowerManagementDefaultLimit, callInfo)
	mock.lockDeviceGetPowerManagementDefaultLimit.Unlock()
	return mock.DeviceGetPowerManagementDefaultLimitFunc(device)
}

// DeviceGetPowerManagementDefaultLimitCalls gets all the calls that were made to DeviceGetPowerManagementDefaultLimit.
// Check the length with:
//
//	len(mockedInterface.DeviceGetPowerManagementDefaultLimitCalls())
func (mock *Interface) DeviceGetPowerManagementDefaultLimitCalls() []struct {
	Device nvml.Device
} {
	var calls []struct {
		Device nvml.Device
	}
	mock.lockDeviceGetPowerManagementDefaultLimit.RLock()
	calls = mock.calls.DeviceGetPowerManagementDefaultLimit
	mock.lockDeviceGetPowerManagementDefaultLimit.RUnlock()
	return calls
}

// DeviceGetPowerManagementLimit calls DeviceGetPowerManagementLimitFunc.
func (mock *Interface) DeviceGetPowerManagementLimit(device nvml.Device) (uint32, nvml.Return) {
	if mock.DeviceGetPowerManagementLimitFunc == nil {
		panic("Interface.DeviceGetPowerManagementLimitFunc: method is nil but Interface.DeviceGetPowerManagementLimit was just called")
	}
	callInfo := struct {
		Device nvml.Device
	}{
		Device: device,
	}
	mock.lockDeviceGetPowerManagementLimit.Lock()
	mock.calls.DeviceGetPowerManagementLimit = append(mock.calls.DeviceGetPowerManagementLimit, callInfo)
	mock.lockDeviceGetPowerManagementLimit.Unlock()
	return mock.DeviceGetPowerManagementLimitFunc(device)
}

// DeviceGetPowerManagementLimitCalls gets all the calls that were made to DeviceGetPowerManagementLimit.
// Check the length with:
//
//	len(mockedInterface.DeviceGetPowerManagementLimitCalls())
func (mock *Interface) DeviceGetPowerManagementLimitCalls() []struct {
	Device nvml.Device
} {
	var calls []struct {
		Device nvml.Device
	}
	mock.lockDeviceGetPowerManagementLimit.RLock()
	calls = mock.calls.DeviceGetPowerManagementLimit
	mock.lockDeviceGetPowerManagementLimit.RUnlock()
	return calls
}

// DeviceGetPowerManagementLimitConstraints calls DeviceGetPowerManagementLimitConstraintsFunc.
func (mock *Interface) DeviceGetPowerManagementLimitConstraints(device nvml.Device) (uint32, uint32, nvml.Return) {
	if mock.DeviceGetPowerManagementLimitConstraintsFunc == nil {
		panic("Interface.DeviceGetPowerManagementLimitConstraintsFunc: method is nil but Interface.DeviceGetPowerManagementLimitConstraints was just called")
	}
	callInfo := struct {
		Device nvml.Device
	}{
		Device: device,
	}
	mock.lockDeviceGetPowerManagementLimitConstraints.Lock()
	mock.calls.DeviceGetPowerManagementLimitConstraints = append(mock.calls.DeviceGetPowerManagementLimitConstraints, callInfo)
	mock.lockDeviceGetPowerManagementLimitConstraints.Unlock()
	return mock.DeviceGetPowerManagementLimitConstraintsFunc(device)
}

// DeviceGetPowerManagementLimitConstraintsCalls gets all the calls that were made to DeviceGetPowerManagementLimitConstraints.
// Check the length with:
//
//	len(mockedInterface.DeviceGetPowerManagementLimitConstraintsCalls())
func (mock *Interface) DeviceGetPowerManagementLimitConstraintsCalls() []struct {
	Device nvml.Device
} {
	var calls []struct {
		Device nvml.Device
	}
	mock.lockDeviceGetPowerManagementLimitConstraints.RLock()
	calls = mock.calls.DeviceGetPowerManagementLimitConstraints
	mock.lockDeviceGetPowerManagementLimitConstraints.RUnlock()
	return calls
}

// DeviceGetPowerManagementMode calls DeviceGetPowerManagementModeFunc.
func (mock *Interface) DeviceGetPowerManagementMode(device nvml.Device) (nvml.EnableState, nvml.Return) {
	if mock.DeviceGetPowerManagementModeFunc == nil {
		panic("Interface.DeviceGetPowerManagementModeFunc: method is nil but Interface.DeviceGetPowerManagementMode was just called")
	}
	callInfo := struct {
		Device nvml.Device
	}{
		Device: device,
	}
	mock.lockDeviceGetPowerManagementMode.Lock()
	mock.calls.DeviceGetPowerManagementMode = append(mock.calls.DeviceGetPowerManagementMode, callInfo)
	mock.lockDeviceGetPowerManagementMode.Unlock()
	return mock.DeviceGetPowerManagementModeFunc(device)
}

// DeviceGetPowerManagementModeCalls gets all the calls that were made to DeviceGetPowerManagementMode.
// Check the length with:
//
//	len(mockedInterface.DeviceGetPowerManagementModeCalls())
func (mock *Interface) DeviceGetPowerManagementModeCalls() []struct {
	Device nvml.Device
} {
	var calls []struct {
		Device nvml.Device
	}
	mock.lockDeviceGetPowerManagementMode.RLock()
	calls = mock.calls.DeviceGetPowerManagementMode
	mock.lockDeviceGetPowerManagementMode.RUnlock()
	return calls
}

// DeviceGetPowerMizerMode_v1 calls DeviceGetPowerMizerMode_v1Func.
func (mock *Interface) DeviceGetPowerMizerMode_v1(device nvml.Device) (nvml.DevicePowerMizerModes_v1, nvml.Return) {
	if mock.DeviceGetPowerMizerMode_v1Func == nil {
		panic("Interface.DeviceGetPowerMizerMode_v1Func: method is nil but Interface.DeviceGetPowerMizerMode_v1 was just called")
	}
	callInfo := struct {
		Device nvml.Device
	}{
		Device: device,
	}
	mock.lockDeviceGetPowerMizerMode_v1.Lock()
	mock.calls.DeviceGetPowerMizerMode_v1 = append(mock.calls.DeviceGetPowerMizerMode_v1, callInfo)
	mock.lockDeviceGetPowerMizerMode_v1.Unlock()
	return mock.DeviceGetPowerMizerMode_v1Func(device)
}

// DeviceGetPowerMizerMode_v1Calls gets all the calls that were made to DeviceGetPowerMizerMode_v1.
// Check the length with:
//
//	len(mockedInterface.DeviceGetPowerMizerMode_v1Calls())
func (mock *Interface) DeviceGetPowerMizerMode_v1Calls() []struct {
	Device nvml.Device
} {
	var calls []struct {
		Device nvml.Device
	}
	mock.lockDeviceGetPowerMizerMode_v1.RLock()
	calls = mock.calls.DeviceGetPowerMizerMode_v1
	mock.lockDeviceGetPowerMizerMode_v1.RUnlock()
	return calls
}

// DeviceGetPowerSource calls DeviceGetPowerSourceFunc.
func (mock *Interface) DeviceGetPowerSource(device nvml.Device) (nvml.PowerSource, nvml.Return) {
	if mock.DeviceGetPowerSourceFunc == nil {
		panic("Interface.DeviceGetPowerSourceFunc: method is nil but Interface.DeviceGetPowerSource was just called")
	}
	callInfo := struct {
		Device nvml.Device
	}{
		Device: device,
	}
	mock.lockDeviceGetPowerSource.Lock()
	mock.calls.DeviceGetPowerSource = append(mock.calls.DeviceGetPowerSource, callInfo)
	mock.lockDeviceGetPowerSource.Unlock()
	return mock.DeviceGetPowerSourceFunc(device)
}

// DeviceGetPowerSourceCalls gets all the calls that were made to DeviceGetPowerSource.
// Check the length with:
//
//	len(mockedInterface.DeviceGetPowerSourceCalls())
func (mock *Interface) DeviceGetPowerSourceCalls() []struct {
	Device nvml.Device
} {
	var calls []struct {
		Device nvml.Device
	}
	mock.lockDeviceGetPowerSource.RLock()
	calls = mock.calls.DeviceGetPowerSource
	mock.lockDeviceGetPowerSource.RUnlock()
	return calls
}

// DeviceGetPowerState calls DeviceGetPowerStateFunc.
func (mock *Interface) DeviceGetPowerState(device nvml.Device) (nvml.Pstates, nvml.Return) {
	if mock.DeviceGetPowerStateFunc == nil {
		panic("Interface.DeviceGetPowerStateFunc: method is nil but Interface.DeviceGetPowerState was just called")
	}
	callInfo := struct {
		Device nvml.Device
	}{
		Device: device,
	}
	mock.lockDeviceGetPowerState.Lock()
	mock.calls.DeviceGetPowerState = append(mock.calls.DeviceGetPowerState, callInfo)
	mock.lockDeviceGetPowerState.Unlock()
	return mock.DeviceGetPowerStateFunc(device)
}

// DeviceGetPowerStateCalls gets all the calls that were made to DeviceGetPowerState.
// Check the length with:
//
//	len(mockedInterface.DeviceGetPowerStateCalls())
func (mock *Interface) DeviceGetPowerStateCalls() []struct {
	Device nvml.Device
} {
	var calls []struct {
		Device nvml.Device
	}
	mock.lockDeviceGetPowerState.RLock()
	calls = mock.calls.DeviceGetPowerState
	mock.lockDeviceGetPowerState.RUnlock()
	return calls
}

// DeviceGetPowerUsage calls DeviceGetPowerUsageFunc.
func (mock *Interface) DeviceGetPowerUsage(device nvml.Device) (uint32, nvml.Return) {
	if mock.DeviceGetPowerUsageFunc == nil {
		panic("Interface.DeviceGetPowerUsageFunc: method is nil but Interface.DeviceGetPowerUsage was just called")
	}
	callInfo := struct {
		Device nvml.Device
	}{
		Device: device,
	}
	mock.lockDeviceGetPowerUsage.Lock()
	mock.calls.DeviceGetPowerUsage = append(mock.calls.DeviceGetPowerUsage, callInfo)
	mock.lockDeviceGetPowerUsage.Unlock()
	return mock.DeviceGetPowerUsageFunc(device)
}

// DeviceGetPowerUsageCalls gets all the calls that were made to DeviceGetPowerUsage.
// Check the length with:
//
//	len(mockedInterface.DeviceGetPowerUsageCalls())
func (mock *Interface) DeviceGetPowerUsageCalls() []struct {
	Device nvml.Device
} {
	var calls []struct {
		Device nvml.Device
	}
	mock.lockDeviceGetPowerUsage.RLock()
	calls = mock.calls.DeviceGetPowerUsage
	mock.lockDeviceGetPowerUsage.RUnlock()
	return calls
}

// DeviceGetProcessUtilization calls DeviceGetProcessUtilizationFunc.
func (mock *Interface) DeviceGetProcessUtilization(device nvml.Device, v uint64) ([]nvml.ProcessUtilizationSample, nvml.Return) {
	if mock.DeviceGetProcessUtilizationFunc == nil {
		panic("Interface.DeviceGetProcessUtilizationFunc: method is nil but Interface.DeviceGetProcessUtilization was just called")
	}
	callInfo := struct {
		Device nvml.Device
		V      uint64
	}{
		Device: device,
		V:      v,
	}
	mock.lockDeviceGetProcessUtilization.Lock()
	mock.calls.DeviceGetProcessUtilization = append(mock.calls.DeviceGetProcessUtilization, callInfo)
	mock.lockDeviceGetProcessUtilization.Unlock()
	return mock.DeviceGetProcessUtilizationFunc(device, v)
}

// DeviceGetProcessUtilizationCalls gets all the calls that were made to DeviceGetProcessUtilization.
// Check the length with:
//
//	len(mockedInterface.DeviceGetProcessUtilizationCalls())
func (mock *Interface) DeviceGetProcessUtilizationCalls() []struct {
	Device nvml.Device
	V      uint64
} {
	var calls []struct {
		Device nvml.Device
		V      uint64
	}
	mock.lockDeviceGetProcessUtilization.RLock()
	calls = mock.calls.DeviceGetProcessUtilization
	mock.lockDeviceGetProcessUtilization.RUnlock()
	return calls
}

// DeviceGetProcessesUtilizationInfo calls DeviceGetProcessesUtilizationInfoFunc.
func (mock *Interface) DeviceGetProcessesUtilizationInfo(device nvml.Device) (nvml.ProcessesUtilizationInfo, nvml.Return) {
	if mock.DeviceGetProcessesUtilizationInfoFunc == nil {
		panic("Interface.DeviceGetProcessesUtilizationInfoFunc: method is nil but Interface.DeviceGetProcessesUtilizationInfo was just called")
	}
	callInfo := struct {
		Device nvml.Device
	}{
		Device: device,
	}
	mock.lockDeviceGetProcessesUtilizationInfo.Lock()
	mock.calls.DeviceGetProcessesUtilizationInfo = append(mock.calls.DeviceGetProcessesUtilizationInfo, callInfo)
	mock.lockDeviceGetProcessesUtilizationInfo.Unlock()
	return mock.DeviceGetProcessesUtilizationInfoFunc(device)
}

// DeviceGetProcessesUtilizationInfoCalls gets all the calls that were made to DeviceGetProcessesUtilizationInfo.
// Check the length with:
//
//	len(mockedInterface.DeviceGetProcessesUtilizationInfoCalls())
func (mock *Interface) DeviceGetProcessesUtilizationInfoCalls() []struct {
	Device nvml.Device
} {
	var calls []struct {
		Device nvml.Device
	}
	mock.lockDeviceGetProcessesUtilizationInfo.RLock()
	calls = mock.calls.DeviceGetProcessesUtilizationInfo
	mock.lockDeviceGetProcessesUtilizationInfo.RUnlock()
	return calls
}

// DeviceGetRemappedRows calls DeviceGetRemappedRowsFunc.
func (mock *Interface) DeviceGetRemappedRows(device nvml.Device) (int, int, bool, bool, nvml.Return) {
	if mock.DeviceGetRemappedRowsFunc == nil {
		panic("Interface.DeviceGetRemappedRowsFunc: method is nil but Interface.DeviceGetRemappedRows was just called")
	}
	callInfo := struct {
		Device nvml.Device
	}{
		Device: device,
	}
	mock.lockDeviceGetRemappedRows.Lock()
	mock.calls.DeviceGetRemappedRows = append(mock.calls.DeviceGetRemappedRows, callInfo)
	mock.lockDeviceGetRemappedRows.Unlock()
	return mock.DeviceGetRemappedRowsFunc(device)
}

// DeviceGetRemappedRowsCalls gets all the calls that were made to DeviceGetRemappedRows.
// Check the length with:
//
//	len(mockedInterface.DeviceGetRemappedRowsCalls())
func (mock *Interface) DeviceGetRemappedRowsCalls() []struct {
	Device nvml.Device
} {
	var calls []struct {
		Device nvml.Device
	}
	mock.lockDeviceGetRemappedRows.RLock()
	calls = mock.calls.DeviceGetRemappedRows
	mock.lockDeviceGetRemappedRows.RUnlock()
	return calls
}

// DeviceGetRepairStatus calls DeviceGetRepairStatusFunc.
func (mock *Interface) DeviceGetRepairStatus(device nvml.Device) (nvml.RepairStatus, nvml.Return) {
	if mock.DeviceGetRepairStatusFunc == nil {
		panic("Interface.DeviceGetRepairStatusFunc: method is nil but Interface.DeviceGetRepairStatus was just called")
	}
	callInfo := struct {
		Device nvml.Device
	}{
		Device: device,
	}
	mock.lockDeviceGetRepairStatus.Lock()
	mock.calls.DeviceGetRepairStatus = append(mock.calls.DeviceGetRepairStatus, callInfo)
	mock.lockDeviceGetRepairStatus.Unlock()
	return mock.DeviceGetRepairStatusFunc(device)
}

// DeviceGetRepairStatusCalls gets all the calls that were made to DeviceGetRepairStatus.
// Check the length with:
//
//	len(mockedInterface.DeviceGetRepairStatusCalls())
func (mock *Interface) DeviceGetRepairStatusCalls() []struct {
	Device nvml.Device
} {
	var calls []struct {
		Device nvml.Device
	}
	mock.lockDeviceGetRepairStatus.RLock()
	calls = mock.calls.DeviceGetRepairStatus
	mock.lockDeviceGetRepairStatus.RUnlock()
	return calls
}

// DeviceGetRetiredPages calls DeviceGetRetiredPagesFunc.
func (mock *Interface) DeviceGetRetiredPages(device nvml.Device, pageRetirementCause nvml.PageRetirementCause) ([]uint64, nvml.Return) {
	if mock.DeviceGetRetiredPagesFunc == nil {
		panic("Interface.DeviceGetRetiredPagesFunc: method is nil but Interface.DeviceGetRetiredPages was just called")
	}
	callInfo := struct {
		Device              nvml.Device
		PageRetirementCause nvml.PageRetirementCause
	}{
		Device:              device,
		PageRetirementCause: pageRetirementCause,
	}
	mock.lockDeviceGetRetiredPages.Lock()
	mock.calls.DeviceGetRetiredPages = append(mock.calls.DeviceGetRetiredPages, callInfo)
	mock.lockDeviceGetRetiredPages.Unlock()
	return mock.DeviceGetRetiredPagesFunc(device, pageRetirementCause)
}

// DeviceGetRetiredPagesCalls gets all the calls that were made to DeviceGetRetiredPages.
// Check the length with:
//
//	len(mockedInterface.DeviceGetRetiredPagesCalls())
func (mock *Interface) DeviceGetRetiredPagesCalls() []struct {
	Device              nvml.Device
	PageRetirementCause nvml.PageRetirementCause
} {
	var calls []struct {
		Device              nvml.Device
		PageRetirementCause nvml.PageRetirementCause
	}
	mock.lockDeviceGetRetiredPages.RLock()
	calls = mock.calls.DeviceGetRetiredPages
	mock.lockDeviceGetRetiredPages.RUnlock()
	return calls
}

// DeviceGetRetiredPagesPendingStatus calls DeviceGetRetiredPagesPendingStatusFunc.
func (mock *Interface) DeviceGetRetiredPagesPendingStatus(device nvml.Device) (nvml.EnableState, nvml.Return) {
	if mock.DeviceGetRetiredPagesPendingStatusFunc == nil {
		panic("Interface.DeviceGetRetiredPagesPendingStatusFunc: method is nil but Interface.DeviceGetRetiredPagesPendingStatus was just called")
	}
	callInfo := struct {
		Device nvml.Device
	}{
		Device: device,
	}
	mock.lockDeviceGetRetiredPagesPendingStatus.Lock()
	mock.calls.DeviceGetRetiredPagesPendingStatus = append(mock.calls.DeviceGetRetiredPagesPendingStatus, callInfo)
	mock.lockDeviceGetRetiredPagesPendingStatus.Unlock()
	return mock.DeviceGetRetiredPagesPendingStatusFunc(device)
}

// DeviceGetRetiredPagesPendingStatusCalls gets all the calls that were made to DeviceGetRetiredPagesPendingStatus.
// Check the length with:
//
//	len(mockedInterface.DeviceGetRetiredPagesPendingStatusCalls())
func (mock *Interface) DeviceGetRetiredPagesPendingStatusCalls() []struct {
	Device nvml.Device
} {
	var calls []struct {
		Device nvml.Device
	}
	mock.lockDeviceGetRetiredPagesPendingStatus.RLock()
	calls = mock.calls.DeviceGetRetiredPagesPendingStatus
	mock.lockDeviceGetRetiredPagesPendingStatus.RUnlock()
	return calls
}

// DeviceGetRetiredPages_v2 calls DeviceGetRetiredPages_v2Func.
func (mock *Interface) DeviceGetRetiredPages_v2(device nvml.Device, pageRetirementCause nvml.PageRetirementCause) ([]uint64, []uint64, nvml.Return) {
	if mock.DeviceGetRetiredPages_v2Func == nil {
		panic("Interface.DeviceGetRetiredPages_v2Func: method is nil but Interface.DeviceGetRetiredPages_v2 was just called")
	}
	callInfo := struct {
		Device              nvml.Device
		PageRetirementCause nvml.PageRetirementCause
	}{
		Device:              device,
		PageRetirementCause: pageRetirementCause,
	}
	mock.lockDeviceGetRetiredPages_v2.Lock()
	mock.calls.DeviceGetRetiredPages_v2 = append(mock.calls.DeviceGetRetiredPages_v2, callInfo)
	mock.lockDeviceGetRetiredPages_v2.Unlock()
	return mock.DeviceGetRetiredPages_v2Func(device, pageRetirementCause)
}

// DeviceGetRetiredPages_v2Calls gets all the calls that were made to DeviceGetRetiredPages_v2.
// Check the length with:
//
//	len(mockedInterface.DeviceGetRetiredPages_v2Calls())
func (mock *Interface) DeviceGetRetiredPages_v2Calls() []struct {
	Device              nvml.Device
	PageRetirementCause nvml.PageRetirementCause
} {
	var calls []struct {
		Device              nvml.Device
		PageRetirementCause nvml.PageRetirementCause
	}
	mock.lockDeviceGetRetiredPages_v2.RLock()
	calls = mock.calls.DeviceGetRetiredPages_v2
	mock.lockDeviceGetRetiredPages_v2.RUnlock()
	return calls
}

// DeviceGetRowRemapperHistogram calls DeviceGetRowRemapperHistogramFunc.
func (mock *Interface) DeviceGetRowRemapperHistogram(device nvml.Device) (nvml.RowRemapperHistogramValues, nvml.Return) {
	if mock.DeviceGetRowRemapperHistogramFunc == nil {
		panic("Interface.DeviceGetRowRemapperHistogramFunc: method is nil but Interface.DeviceGetRowRemapperHistogram was just called")
	}
	callInfo := struct {
		Device nvml.Device
	}{
		Device: device,
	}
	mock.lockDeviceGetRowRemapperHistogram.Lock()
	mock.calls.DeviceGetRowRemapperHistogram = append(mock.calls.DeviceGetRowRemapperHistogram, callInfo)
	mock.lockDeviceGetRowRemapperHistogram.Unlock()
	return mock.DeviceGetRowRemapperHistogramFunc(device)
}

// DeviceGetRowRemapperHistogramCalls gets all the calls that were made to DeviceGetRowRemapperHistogram.
// Check the length with:
//
//	len(mockedInterface.DeviceGetRowRemapperHistogramCalls())
func (mock *Interface) DeviceGetRowRemapperHistogramCalls() []struct {
	Device nvml.Device
} {
	var calls []struct {
		Device nvml.Device
	}
	mock.lockDeviceGetRowRemapperHistogram.RLock()
	calls = mock.calls.DeviceGetRowRemapperHistogram
	mock.lockDeviceGetRowRemapperHistogram.RUnlock()
	return calls
}

// DeviceGetRunningProcessDetailList calls DeviceGetRunningProcessDetailListFunc.
func (mock *Interface) DeviceGetRunningProcessDetailList(device nvml.Device) (nvml.ProcessDetailList, nvml.Return) {
	if mock.DeviceGetRunningProcessDetailListFunc == nil {
		panic("Interface.DeviceGetRunningProcessDetailListFunc: method is nil but Interface.DeviceGetRunningProcessDetailList was just called")
	}
	callInfo := struct {
		Device nvml.Device
	}{
		Device: device,
	}
	mock.lockDeviceGetRunningProcessDetailList.Lock()
	mock.calls.DeviceGetRunningProcessDetailList = append(mock.calls.DeviceGetRunningProcessDetailList, callInfo)
	mock.lockDeviceGetRunningProcessDetailList.Unlock()
	return mock.DeviceGetRunningProcessDetailListFunc(device)
}

// DeviceGetRunningProcessDetailListCalls gets all the calls that were made to DeviceGetRunningProcessDetailList.
// Check the length with:
//
//	len(mockedInterface.DeviceGetRunningProcessDetailListCalls())
func (mock *Interface) DeviceGetRunningProcessDetailListCalls() []struct {
	Device nvml.Device
} {
	var calls []struct {
		Device nvml.Device
	}
	mock.lockDeviceGetRunningProcessDetailList.RLock()
	calls = mock.calls.DeviceGetRunningProcessDetailList
	mock.lockDeviceGetRunningProcessDetailList.RUnlock()
	return calls
}

// DeviceGetSamples calls DeviceGetSamplesFunc.
func (mock *Interface) DeviceGetSamples(device nvml.Device, samplingType nvml.SamplingType, v uint64) (nvml.ValueType, []nvml.Sample, nvml.Return) {
	if mock.DeviceGetSamplesFunc == nil {
		panic("Interface.DeviceGetSamplesFunc: method is nil but Interface.DeviceGetSamples was just called")
	}
	callInfo := struct {
		Device       nvml.Device
		SamplingType nvml.SamplingType
		V            uint64
	}{
		Device:       device,
		SamplingType: samplingType,
		V:            v,
	}
	mock.lockDeviceGetSamples.Lock()
	mock.calls.DeviceGetSamples = append(mock.calls.DeviceGetSamples, callInfo)
	mock.lockDeviceGetSamples.Unlock()
	return mock.DeviceGetSamplesFunc(device, samplingType, v)
}

// DeviceGetSamplesCalls gets all the calls that were made to DeviceGetSamples.
// Check the length with:
//
//	len(mockedInterface.DeviceGetSamplesCalls())
func (mock *Interface) DeviceGetSamplesCalls() []struct {
	Device       nvml.Device
	SamplingType nvml.SamplingType
	V            uint64
} {
	var calls []struct {
		Device       nvml.Device
		SamplingType nvml.SamplingType
		V            uint64
	}
	mock.lockDeviceGetSamples.RLock()
	calls = mock.calls.DeviceGetSamples
	mock.lockDeviceGetSamples.RUnlock()
	return calls
}

// DeviceGetSerial calls DeviceGetSerialFunc.
func (mock *Interface) DeviceGetSerial(device nvml.Device) (string, nvml.Return) {
	if mock.DeviceGetSerialFunc == nil {
		panic("Interface.DeviceGetSerialFunc: method is nil but Interface.DeviceGetSerial was just called")
	}
	callInfo := struct {
		Device nvml.Device
	}{
		Device: device,
	}
	mock.lockDeviceGetSerial.Lock()
	mock.calls.DeviceGetSerial = append(mock.calls.DeviceGetSerial, callInfo)
	mock.lockDeviceGetSerial.Unlock()
	return mock.DeviceGetSerialFunc(device)
}

// DeviceGetSerialCalls gets all the calls that were made to DeviceGetSerial.
// Check the length with:
//
//	len(mockedInterface.DeviceGetSerialCalls())
func (mock *Interface) DeviceGetSerialCalls() []struct {
	Device nvml.Device
} {
	var calls []struct {
		Device nvml.Device
	}
	mock.lockDeviceGetSerial.RLock()
	calls = mock.calls.DeviceGetSerial
	mock.lockDeviceGetSerial.RUnlock()
	return calls
}

// DeviceGetSramEccErrorStatus calls DeviceGetSramEccErrorStatusFunc.
func (mock *Interface) DeviceGetSramEccErrorStatus(device nvml.Device) (nvml.EccSramErrorStatus, nvml.Return) {
	if mock.DeviceGetSramEccErrorStatusFunc == nil {
		panic("Interface.DeviceGetSramEccErrorStatusFunc: method is nil but Interface.DeviceGetSramEccErrorStatus was just called")
	}
	callInfo := struct {
		Device nvml.Device
	}{
		Device: device,
	}
	mock.lockDeviceGetSramEccErrorStatus.Lock()
	mock.calls.DeviceGetSramEccErrorStatus = append(mock.calls.DeviceGetSramEccErrorStatus, callInfo)
	mock.lockDeviceGetSramEccErrorStatus.Unlock()
	return mock.DeviceGetSramEccErrorStatusFunc(device)
}

// DeviceGetSramEccErrorStatusCalls gets all the calls that were made to DeviceGetSramEccErrorStatus.
// Check the length with:
//
//	len(mockedInterface.DeviceGetSramEccErrorStatusCalls())
func (mock *Interface) DeviceGetSramEccErrorStatusCalls() []struct {
	Device nvml.Device
} {
	var calls []struct {
		Device nvml.Device
	}
	mock.lockDeviceGetSramEccErrorStatus.RLock()
	calls = mock.calls.DeviceGetSramEccErrorStatus
	mock.lockDeviceGetSramEccErrorStatus.RUnlock()
	return calls
}

// DeviceGetSramUniqueUncorrectedEccErrorCounts calls DeviceGetSramUniqueUncorrectedEccErrorCountsFunc.
func (mock *Interface) DeviceGetSramUniqueUncorrectedEccErrorCounts(device nvml.Device, eccSramUniqueUncorrectedErrorCounts *nvml.EccSramUniqueUncorrectedErrorCounts) nvml.Return {
	if mock.DeviceGetSramUniqueUncorrectedEccErrorCountsFunc == nil {
		panic("Interface.DeviceGetSramUniqueUncorrectedEccErrorCountsFunc: method is nil but Interface.DeviceGetSramUniqueUncorrectedEccErrorCounts was just called")
	}
	callInfo := struct {
		Device                              nvml.Device
		EccSramUniqueUncorrectedErrorCounts *nvml.EccSramUniqueUncorrectedErrorCounts
	}{
		Device:                              device,
		EccSramUniqueUncorrectedErrorCounts: eccSramUniqueUncorrectedErrorCounts,
	}
	mock.lockDeviceGetSramUniqueUncorrectedEccErrorCounts.Lock()
	mock.calls.DeviceGetSramUniqueUncorrectedEccErrorCounts = append(mock.calls.DeviceGetSramUniqueUncorrectedEccErrorCounts, callInfo)
	mock.lockDeviceGetSramUniqueUncorrectedEccErrorCounts.Unlock()
	return mock.DeviceGetSramUniqueUncorrectedEccErrorCountsFunc(device, eccSramUniqueUncorrectedErrorCounts)
}

// DeviceGetSramUniqueUncorrectedEccErrorCountsCalls gets all the calls that were made to DeviceGetSramUniqueUncorrectedEccErrorCounts.
// Check the length with:
//
//	len(mockedInterface.DeviceGetSramUniqueUncorrectedEccErrorCountsCalls())
func (mock *Interface) DeviceGetSramUniqueUncorrectedEccErrorCountsCalls() []struct {
	Device                              nvml.Device
	EccSramUniqueUncorrectedErrorCounts *nvml.EccSramUniqueUncorrectedErrorCounts
} {
	var calls []struct {
		Device                              nvml.Device
		EccSramUniqueUncorrectedErrorCounts *nvml.EccSramUniqueUncorrectedErrorCounts
	}
	mock.lockDeviceGetSramUniqueUncorrectedEccErrorCounts.RLock()
	calls = mock.calls.DeviceGetSramUniqueUncorrectedEccErrorCounts
	mock.lockDeviceGetSramUniqueUncorrectedEccErrorCounts.RUnlock()
	return calls
}

// DeviceGetSupportedClocksEventReasons calls DeviceGetSupportedClocksEventReasonsFunc.
func (mock *Interface) DeviceGetSupportedClocksEventReasons(device nvml.Device) (uint64, nvml.Return) {
	if mock.DeviceGetSupportedClocksEventReasonsFunc == nil {
		panic("Interface.DeviceGetSupportedClocksEventReasonsFunc: method is nil but Interface.DeviceGetSupportedClocksEventReasons was just called")
	}
	callInfo := struct {
		Device nvml.Device
	}{
		Device: device,
	}
	mock.lockDeviceGetSupportedClocksEventReasons.Lock()
	mock.calls.DeviceGetSupportedClocksEventReasons = append(mock.calls.DeviceGetSupportedClocksEventReasons, callInfo)
	mock.lockDeviceGetSupportedClocksEventReasons.Unlock()
	return mock.DeviceGetSupportedClocksEventReasonsFunc(device)
}

// DeviceGetSupportedClocksEventReasonsCalls gets all the calls that were made to DeviceGetSupportedClocksEventReasons.
// Check the length with:
//
//	len(mockedInterface.DeviceGetSupportedClocksEventReasonsCalls())
func (mock *Interface) DeviceGetSupportedClocksEventReasonsCalls() []struct {
	Device nvml.Device
} {
	var calls []struct {
		Device nvml.Device
	}
	mock.lockDeviceGetSupportedClocksEventReasons.RLock()
	calls = mock.calls.DeviceGetSupportedClocksEventReasons
	mock.lockDeviceGetSupportedClocksEventReasons.RUnlock()
	return calls
}

// DeviceGetSupportedClocksThrottleReasons calls DeviceGetSupportedClocksThrottleReasonsFunc.
func (mock *Interface) DeviceGetSupportedClocksThrottleReasons(device nvml.Device) (uint64, nvml.Return) {
	if mock.DeviceGetSupportedClocksThrottleReasonsFunc == nil {
		panic("Interface.DeviceGetSupportedClocksThrottleReasonsFunc: method is nil but Interface.DeviceGetSupportedClocksThrottleReasons was just called")
	}
	callInfo := struct {
		Device nvml.Device
	}{
		Device: device,
	}
	mock.lockDeviceGetSupportedClocksThrottleReasons.Lock()
	mock.calls.DeviceGetSupportedClocksThrottleReasons = append(mock.calls.DeviceGetSupportedClocksThrottleReasons, callInfo)
	mock.lockDeviceGetSupportedClocksThrottleReasons.Unlock()
	return mock.DeviceGetSupportedClocksThrottleReasonsFunc(device)
}

// DeviceGetSupportedClocksThrottleReasonsCalls gets all the calls that were made to DeviceGetSupportedClocksThrottleReasons.
// Check the length with:
//
//	len(mockedInterface.DeviceGetSupportedClocksThrottleReasonsCalls())
func (mock *Interface) DeviceGetSupportedClocksThrottleReasonsCalls() []struct {
	Device nvml.Device
} {
	var calls []struct {
		Device nvml.Device
	}
	mock.lockDeviceGetSupportedClocksThrottleReasons.RLock()
	calls = mock.calls.DeviceGetSupportedClocksThrottleReasons
	mock.lockDeviceGetSupportedClocksThrottleReasons.RUnlock()
	return calls
}

// DeviceGetSupportedEventTypes calls DeviceGetSupportedEventTypesFunc.
func (mock *Interface) DeviceGetSupportedEventTypes(device nvml.Device) (uint64, nvml.Return) {
	if mock.DeviceGetSupportedEventTypesFunc == nil {
		panic("Interface.DeviceGetSupportedEventTypesFunc: method is nil but Interface.DeviceGetSupportedEventTypes was just called")
	}
	callInfo := struct {
		Device nvml.Device
	}{
		Device: device,
	}
	mock.lockDeviceGetSupportedEventTypes.Lock()
	mock.calls.DeviceGetSupportedEventTypes = append(mock.calls.DeviceGetSupportedEventTypes, callInfo)
	mock.lockDeviceGetSupportedEventTypes.Unlock()
	return mock.DeviceGetSupportedEventTypesFunc(device)
}

// DeviceGetSupportedEventTypesCalls gets all the calls that were made to DeviceGetSupportedEventTypes.
// Check the length with:
//
//	len(mockedInterface.DeviceGetSupportedEventTypesCalls())
func (mock *Interface) DeviceGetSupportedEventTypesCalls() []struct {
	Device nvml.Device
} {
	var calls []struct {
		Device nvml.Device
	}
	mock.lockDeviceGetSupportedEventTypes.RLock()
	calls = mock.calls.DeviceGetSupportedEventTypes
	mock.lockDeviceGetSupportedEventTypes.RUnlock()
	return calls
}

// DeviceGetSupportedGraphicsClocks calls DeviceGetSupportedGraphicsClocksFunc.
func (mock *Interface) DeviceGetSupportedGraphicsClocks(device nvml.Device, n int) (int, uint32, nvml.Return) {
	if mock.DeviceGetSupportedGraphicsClocksFunc == nil {
		panic("Interface.DeviceGetSupportedGraphicsClocksFunc: method is nil but Interface.DeviceGetSupportedGraphicsClocks was just called")
	}
	callInfo := struct {
		Device nvml.Device
		N      int
	}{
		Device: device,
		N:      n,
	}
	mock.lockDeviceGetSupportedGraphicsClocks.Lock()
	mock.calls.DeviceGetSupportedGraphicsClocks = append(mock.calls.DeviceGetSupportedGraphicsClocks, callInfo)
	mock.lockDeviceGetSupportedGraphicsClocks.Unlock()
	return mock.DeviceGetSupportedGraphicsClocksFunc(device, n)
}

// DeviceGetSupportedGraphicsClocksCalls gets all the calls that were made to DeviceGetSupportedGraphicsClocks.
// Check the length with:
//
//	len(mockedInterface.DeviceGetSupportedGraphicsClocksCalls())
func (mock *Interface) DeviceGetSupportedGraphicsClocksCalls() []struct {
	Device nvml.Device
	N      int
} {
	var calls []struct {
		Device nvml.Device
		N      int
	}
	mock.lockDeviceGetSupportedGraphicsClocks.RLock()
	calls = mock.calls.DeviceGetSupportedGraphicsClocks
	mock.lockDeviceGetSupportedGraphicsClocks.RUnlock()
	return calls
}

// DeviceGetSupportedMemoryClocks calls DeviceGetSupportedMemoryClocksFunc.
func (mock *Interface) DeviceGetSupportedMemoryClocks(device nvml.Device) (int, uint32, nvml.Return) {
	if mock.DeviceGetSupportedMemoryClocksFunc == nil {
		panic("Interface.DeviceGetSupportedMemoryClocksFunc: method is nil but Interface.DeviceGetSupportedMemoryClocks was just called")
	}
	callInfo := struct {
		Device nvml.Device
	}{
		Device: device,
	}
	mock.lockDeviceGetSupportedMemoryClocks.Lock()
	mock.calls.DeviceGetSupportedMemoryClocks = append(mock.calls.DeviceGetSupportedMemoryClocks, callInfo)
	mock.lockDeviceGetSupportedMemoryClocks.Unlock()
	return mock.DeviceGetSupportedMemoryClocksFunc(device)
}

// DeviceGetSupportedMemoryClocksCalls gets all the calls that were made to DeviceGetSupportedMemoryClocks.
// Check the length with:
//
//	len(mockedInterface.DeviceGetSupportedMemoryClocksCalls())
func (mock *Interface) DeviceGetSupportedMemoryClocksCalls() []struct {
	Device nvml.Device
} {
	var calls []struct {
		Device nvml.Device
	}
	mock.lockDeviceGetSupportedMemoryClocks.RLock()
	calls = mock.calls.DeviceGetSupportedMemoryClocks
	mock.lockDeviceGetSupportedMemoryClocks.RUnlock()
	return calls
}

// DeviceGetSupportedPerformanceStates calls DeviceGetSupportedPerformanceStatesFunc.
func (mock *Interface) DeviceGetSupportedPerformanceStates(device nvml.Device) ([]nvml.Pstates, nvml.Return) {
	if mock.DeviceGetSupportedPerformanceStatesFunc == nil {
		panic("Interface.DeviceGetSupportedPerformanceStatesFunc: method is nil but Interface.DeviceGetSupportedPerformanceStates was just called")
	}
	callInfo := struct {
		Device nvml.Device
	}{
		Device: device,
	}
	mock.lockDeviceGetSupportedPerformanceStates.Lock()
	mock.calls.DeviceGetSupportedPerformanceStates = append(mock.calls.DeviceGetSupportedPerformanceStates, callInfo)
	mock.lockDeviceGetSupportedPerformanceStates.Unlock()
	return mock.DeviceGetSupportedPerformanceStatesFunc(device)
}

// DeviceGetSupportedPerformanceStatesCalls gets all the calls that were made to DeviceGetSupportedPerformanceStates.
// Check the length with:
//
//	len(mockedInterface.DeviceGetSupportedPerformanceStatesCalls())
func (mock *Interface) DeviceGetSupportedPerformanceStatesCalls() []struct {
	Device nvml.Device
} {
	var calls []struct {
		Device nvml.Device
	}
	mock.lockDeviceGetSupportedPerformanceStates.RLock()
	calls = mock.calls.DeviceGetSupportedPerformanceStates
	mock.lockDeviceGetSupportedPerformanceStates.RUnlock()
	return calls
}

// DeviceGetSupportedVgpus calls DeviceGetSupportedVgpusFunc.
func (mock *Interface) DeviceGetSupportedVgpus(device nvml.Device) ([]nvml.VgpuTypeId, nvml.Return) {
	if mock.DeviceGetSupportedVgpusFunc == nil {
		panic("Interface.DeviceGetSupportedVgpusFunc: method is nil but Interface.DeviceGetSupportedVgpus was just called")
	}
	callInfo := struct {
		Device nvml.Device
	}{
		Device: device,
	}
	mock.lockDeviceGetSupportedVgpus.Lock()
	mock.calls.DeviceGetSupportedVgpus = append(mock.calls.DeviceGetSupportedVgpus, callInfo)
	mock.lockDeviceGetSupportedVgpus.Unlock()
	return mock.DeviceGetSupportedVgpusFunc(device)
}

// DeviceGetSupportedVgpusCalls gets all the calls that were made to DeviceGetSupportedVgpus.
// Check the length with:
//
//	len(mockedInterface.DeviceGetSupportedVgpusCalls())
func (mock *Interface) DeviceGetSupportedVgpusCalls() []struct {
	Device nvml.Device
} {
	var calls []struct {
		Device nvml.Device
	}
	mock.lockDeviceGetSupportedVgpus.RLock()
	calls = mock.calls.DeviceGetSupportedVgpus
	mock.lockDeviceGetSupportedVgpus.RUnlock()
	return calls
}

// DeviceGetTargetFanSpeed calls DeviceGetTargetFanSpeedFunc.
func (mock *Interface) DeviceGetTargetFanSpeed(device nvml.Device, n int) (int, nvml.Return) {
	if mock.DeviceGetTargetFanSpeedFunc == nil {
		panic("Interface.DeviceGetTargetFanSpeedFunc: method is nil but Interface.DeviceGetTargetFanSpeed was just called")
	}
	callInfo := struct {
		Device nvml.Device
		N      int
	}{
		Device: device,
		N:      n,
	}
	mock.lockDeviceGetTargetFanSpeed.Lock()
	mock.calls.DeviceGetTargetFanSpeed = append(mock.calls.DeviceGetTargetFanSpeed, callInfo)
	mock.lockDeviceGetTargetFanSpeed.Unlock()
	return mock.DeviceGetTargetFanSpeedFunc(device, n)
}

// DeviceGetTargetFanSpeedCalls gets all the calls that were made to DeviceGetTargetFanSpeed.
// Check the length with:
//
//	len(mockedInterface.DeviceGetTargetFanSpeedCalls())
func (mock *Interface) DeviceGetTargetFanSpeedCalls() []struct {
	Device nvml.Device
	N      int
} {
	var calls []struct {
		Device nvml.Device
		N      int
	}
	mock.lockDeviceGetTargetFanSpeed.RLock()
	calls = mock.calls.DeviceGetTargetFanSpeed
	mock.lockDeviceGetTargetFanSpeed.RUnlock()
	return calls
}

// DeviceGetTemperature calls DeviceGetTemperatureFunc.
func (mock *Interface) DeviceGetTemperature(device nvml.Device, temperatureSensors nvml.TemperatureSensors) (uint32, nvml.Return) {
	if mock.DeviceGetTemperatureFunc == nil {
		panic("Interface.DeviceGetTemperatureFunc: method is nil but Interface.DeviceGetTemperature was just called")
	}
	callInfo := struct {
		Device             nvml.Device
		TemperatureSensors nvml.TemperatureSensors
	}{
		Device:             device,
		TemperatureSensors: temperatureSensors,
	}
	mock.lockDeviceGetTemperature.Lock()
	mock.calls.DeviceGetTemperature = append(mock.calls.DeviceGetTemperature, callInfo)
	mock.lockDeviceGetTemperature.Unlock()
	return mock.DeviceGetTemperatureFunc(device, temperatureSensors)
}

// DeviceGetTemperatureCalls gets all the calls that were made to DeviceGetTemperature.
// Check the length with:
//
//	len(mockedInterface.DeviceGetTemperatureCalls())
func (mock *Interface) DeviceGetTemperatureCalls() []struct {
	Device             nvml.Device
	TemperatureSensors nvml.TemperatureSensors
} {
	var calls []struct {
		Device             nvml.Device
		TemperatureSensors nvml.TemperatureSensors
	}
	mock.lockDeviceGetTemperature.RLock()
	calls = mock.calls.DeviceGetTemperature
	mock.lockDeviceGetTemperature.RUnlock()
	return calls
}

// DeviceGetTemperatureThreshold calls DeviceGetTemperatureThresholdFunc.
func (mock *Interface) DeviceGetTemperatureThreshold(device nvml.Device, temperatureThresholds nvml.TemperatureThresholds) (uint32, nvml.Return) {
	if mock.DeviceGetTemperatureThresholdFunc == nil {
		panic("Interface.DeviceGetTemperatureThresholdFunc: method is nil but Interface.DeviceGetTemperatureThreshold was just called")
	}
	callInfo := struct {
		Device                nvml.Device
		TemperatureThresholds nvml.TemperatureThresholds
	}{
		Device:                device,
		TemperatureThresholds: temperatureThresholds,
	}
	mock.lockDeviceGetTemperatureThreshold.Lock()
	mock.calls.DeviceGetTemperatureThreshold = append(mock.calls.DeviceGetTemperatureThreshold, callInfo)
	mock.lockDeviceGetTemperatureThreshold.Unlock()
	return mock.DeviceGetTemperatureThresholdFunc(device, temperatureThresholds)
}

// DeviceGetTemperatureThresholdCalls gets all the calls that were made to DeviceGetTemperatureThreshold.
// Check the length with:
//
//	len(mockedInterface.DeviceGetTemperatureThresholdCalls())
func (mock *Interface) DeviceGetTemperatureThresholdCalls() []struct {
	Device                nvml.Device
	TemperatureThresholds nvml.TemperatureThresholds
} {
	var calls []struct {
		Device                nvml.Device
		TemperatureThresholds nvml.TemperatureThresholds
	}
	mock.lockDeviceGetTemperatureThreshold.RLock()
	calls = mock.calls.DeviceGetTemperatureThreshold
	mock.lockDeviceGetTemperatureThreshold.RUnlock()
	return calls
}

// DeviceGetTemperatureV calls DeviceGetTemperatureVFunc.
func (mock *Interface) DeviceGetTemperatureV(device nvml.Device) nvml.TemperatureHandler {
	if mock.DeviceGetTemperatureVFunc == nil {
		panic("Interface.DeviceGetTemperatureVFunc: method is nil but Interface.DeviceGetTemperatureV was just called")
	}
	callInfo := struct {
		Device nvml.Device
	}{
		Device: device,
	}
	mock.lockDeviceGetTemperatureV.Lock()
	mock.calls.DeviceGetTemperatureV = append(mock.calls.DeviceGetTemperatureV, callInfo)
	mock.lockDeviceGetTemperatureV.Unlock()
	return mock.DeviceGetTemperatureVFunc(device)
}

// DeviceGetTemperatureVCalls gets all the calls that were made to DeviceGetTemperatureV.
// Check the length with:
//
//	len(mockedInterface.DeviceGetTemperatureVCalls())
func (mock *Interface) DeviceGetTemperatureVCalls() []struct {
	Device nvml.Device
} {
	var calls []struct {
		Device nvml.Device
	}
	mock.lockDeviceGetTemperatureV.RLock()
	calls = mock.calls.DeviceGetTemperatureV
	mock.lockDeviceGetTemperatureV.RUnlock()
	return calls
}

// DeviceGetThermalSettings calls DeviceGetThermalSettingsFunc.
func (mock *Interface) DeviceGetThermalSettings(device nvml.Device, v uint32) (nvml.GpuThermalSettings, nvml.Return) {
	if mock.DeviceGetThermalSettingsFunc == nil {
		panic("Interface.DeviceGetThermalSettingsFunc: method is nil but Interface.DeviceGetThermalSettings was just called")
	}
	callInfo := struct {
		Device nvml.Device
		V      uint32
	}{
		Device: device,
		V:      v,
	}
	mock.lockDeviceGetThermalSettings.Lock()
	mock.calls.DeviceGetThermalSettings = append(mock.calls.DeviceGetThermalSettings, callInfo)
	mock.lockDeviceGetThermalSettings.Unlock()
	return mock.DeviceGetThermalSettingsFunc(device, v)
}

// DeviceGetThermalSettingsCalls gets all the calls that were made to DeviceGetThermalSettings.
// Check the length with:
//
//	len(mockedInterface.DeviceGetThermalSettingsCalls())
func (mock *Interface) DeviceGetThermalSettingsCalls() []struct {
	Device nvml.Device
	V      uint32
} {
	var calls []struct {
		Device nvml.Device
		V      uint32
	}
	mock.lockDeviceGetThermalSettings.RLock()
	calls = mock.calls.DeviceGetThermalSettings
	mock.lockDeviceGetThermalSettings.RUnlock()
	return calls
}

// DeviceGetTopologyCommonAncestor calls DeviceGetTopologyCommonAncestorFunc.
func (mock *Interface) DeviceGetTopologyCommonAncestor(device1 nvml.Device, device2 nvml.Device) (nvml.GpuTopologyLevel, nvml.Return) {
	if mock.DeviceGetTopologyCommonAncestorFunc == nil {
		panic("Interface.DeviceGetTopologyCommonAncestorFunc: method is nil but Interface.DeviceGetTopologyCommonAncestor was just called")
	}
	callInfo := struct {
		Device1 nvml.Device
		Device2 nvml.Device
	}{
		Device1: device1,
		Device2: device2,
	}
	mock.lockDeviceGetTopologyCommonAncestor.Lock()
	mock.calls.DeviceGetTopologyCommonAncestor = append(mock.calls.DeviceGetTopologyCommonAncestor, callInfo)
	mock.lockDeviceGetTopologyCommonAncestor.Unlock()
	return mock.DeviceGetTopologyCommonAncestorFunc(device1, device2)
}

// DeviceGetTopologyCommonAncestorCalls gets all the calls that were made to DeviceGetTopologyCommonAncestor.
// Check the length with:
//
//	len(mockedInterface.DeviceGetTopologyCommonAncestorCalls())
func (mock *Interface) DeviceGetTopologyCommonAncestorCalls() []struct {
	Device1 nvml.Device
	Device2 nvml.Device
} {
	var calls []struct {
		Device1 nvml.Device
		Device2 nvml.Device
	}
	mock.lockDeviceGetTopologyCommonAncestor.RLock()
	calls = mock.calls.DeviceGetTopologyCommonAncestor
	mock.lockDeviceGetTopologyCommonAncestor.RUnlock()
	return calls
}

// DeviceGetTopologyNearestGpus calls DeviceGetTopologyNearestGpusFunc.
func (mock *Interface) DeviceGetTopologyNearestGpus(device nvml.Device, gpuTopologyLevel nvml.GpuTopologyLevel) ([]nvml.Device, nvml.Return) {
	if mock.DeviceGetTopologyNearestGpusFunc == nil {
		panic("Interface.DeviceGetTopologyNearestGpusFunc: method is nil but Interface.DeviceGetTopologyNearestGpus was just called")
	}
	callInfo := struct {
		Device           nvml.Device
		GpuTopologyLevel nvml.GpuTopologyLevel
	}{
		Device:           device,
		GpuTopologyLevel: gpuTopologyLevel,
	}
	mock.lockDeviceGetTopologyNearestGpus.Lock()
	mock.calls.DeviceGetTopologyNearestGpus = append(mock.calls.DeviceGetTopologyNearestGpus, callInfo)
	mock.lockDeviceGetTopologyNearestGpus.Unlock()
	return mock.DeviceGetTopologyNearestGpusFunc(device, gpuTopologyLevel)
}

// DeviceGetTopologyNearestGpusCalls gets all the calls that were made to DeviceGetTopologyNearestGpus.
// Check the length with:
//
//	len(mockedInterface.DeviceGetTopologyNearestGpusCalls())
func (mock *Interface) DeviceGetTopologyNearestGpusCalls() []struct {
	Device           nvml.Device
	GpuTopologyLevel nvml.GpuTopologyLevel
} {
	var calls []struct {
		Device           nvml.Device
		GpuTopologyLevel nvml.GpuTopologyLevel
	}
	mock.lockDeviceGetTopologyNearestGpus.RLock()
	calls = mock.calls.DeviceGetTopologyNearestGpus
	mock.lockDeviceGetTopologyNearestGpus.RUnlock()
	return calls
}

// DeviceGetTotalEccErrors calls DeviceGetTotalEccErrorsFunc.
func (mock *Interface) DeviceGetTotalEccErrors(device nvml.Device, memoryErrorType nvml.MemoryErrorType, eccCounterType nvml.EccCounterType) (uint64, nvml.Return) {
	if mock.DeviceGetTotalEccErrorsFunc == nil {
		panic("Interface.DeviceGetTotalEccErrorsFunc: method is nil but Interface.DeviceGetTotalEccErrors was just called")
	}
	callInfo := struct {
		Device          nvml.Device
		MemoryErrorType nvml.MemoryErrorType
		EccCounterType  nvml.EccCounterType
	}{
		Device:          device,
		MemoryErrorType: memoryErrorType,
		EccCounterType:  eccCounterType,
	}
	mock.lockDeviceGetTotalEccErrors.Lock()
	mock.calls.DeviceGetTotalEccErrors = append(mock.calls.DeviceGetTotalEccErrors, callInfo)
	mock.lockDeviceGetTotalEccErrors.Unlock()
	return mock.DeviceGetTotalEccErrorsFunc(device, memoryErrorType, eccCounterType)
}

// DeviceGetTotalEccErrorsCalls gets all the calls that were made to DeviceGetTotalEccErrors.
// Check the length with:
//
//	len(mockedInterface.DeviceGetTotalEccErrorsCalls())
func (mock *Interface) DeviceGetTotalEccErrorsCalls() []struct {
	Device          nvml.Device
	MemoryErrorType nvml.MemoryErrorType
	EccCounterType  nvml.EccCounterType
} {
	var calls []struct {
		Device          nvml.Device
		MemoryErrorType nvml.MemoryErrorType
		EccCounterType  nvml.EccCounterType
	}
	mock.lockDeviceGetTotalEccErrors.RLock()
	calls = mock.calls.DeviceGetTotalEccErrors
	mock.lockDeviceGetTotalEccErrors.RUnlock()
	return calls
}

// DeviceGetTotalEnergyConsumption calls DeviceGetTotalEnergyConsumptionFunc.
func (mock *Interface) DeviceGetTotalEnergyConsumption(device nvml.Device) (uint64, nvml.Return) {
	if mock.DeviceGetTotalEnergyConsumptionFunc == nil {
		panic("Interface.DeviceGetTotalEnergyConsumptionFunc: method is nil but Interface.DeviceGetTotalEnergyConsumption was just called")
	}
	callInfo := struct {
		Device nvml.Device
	}{
		Device: device,
	}
	mock.lockDeviceGetTotalEnergyConsumption.Lock()
	mock.calls.DeviceGetTotalEnergyConsumption = append(mock.calls.DeviceGetTotalEnergyConsumption, callInfo)
	mock.lockDeviceGetTotalEnergyConsumption.Unlock()
	return mock.DeviceGetTotalEnergyConsumptionFunc(device)
}

// DeviceGetTotalEnergyConsumptionCalls gets all the calls that were made to DeviceGetTotalEnergyConsumption.
// Check the length with:
//
//	len(mockedInterface.DeviceGetTotalEnergyConsumptionCalls())
func (mock *Interface) DeviceGetTotalEnergyConsumptionCalls() []struct {
	Device nvml.Device
} {
	var calls []struct {
		Device nvml.Device
	}
	mock.lockDeviceGetTotalEnergyConsumption.RLock()
	calls = mock.calls.DeviceGetTotalEnergyConsumption
	mock.lockDeviceGetTotalEnergyConsumption.RUnlock()
	return calls
}

// DeviceGetUUID calls DeviceGetUUIDFunc.
func (mock *Interface) DeviceGetUUID(device nvml.Device) (string, nvml.Return) {
	if mock.DeviceGetUUIDFunc == nil {
		panic("Interface.DeviceGetUUIDFunc: method is nil but Interface.DeviceGetUUID was just called")
	}
	callInfo := struct {
		Device nvml.Device
	}{
		Device: device,
	}
	mock.lockDeviceGetUUID.Lock()
	mock.calls.DeviceGetUUID = append(mock.calls.DeviceGetUUID, callInfo)
	mock.lockDeviceGetUUID.Unlock()
	return mock.DeviceGetUUIDFunc(device)
}

// DeviceGetUUIDCalls gets all the calls that were made to DeviceGetUUID.
// Check the length with:
//
//	len(mockedInterface.DeviceGetUUIDCalls())
func (mock *Interface) DeviceGetUUIDCalls() []struct {
	Device nvml.Device
} {
	var calls []struct {
		Device nvml.Device
	}
	mock.lockDeviceGetUUID.RLock()
	calls = mock.calls.DeviceGetUUID
	mock.lockDeviceGetUUID.RUnlock()
	return calls
}

// DeviceGetUtilizationRates calls DeviceGetUtilizationRatesFunc.
func (mock *Interface) DeviceGetUtilizationRates(device nvml.Device) (nvml.Utilization, nvml.Return) {
	if mock.DeviceGetUtilizationRatesFunc == nil {
		panic("Interface.DeviceGetUtilizationRatesFunc: method is nil but Interface.DeviceGetUtilizationRates was just called")
	}
	callInfo := struct {
		Device nvml.Device
	}{
		Device: device,
	}
	mock.lockDeviceGetUtilizationRates.Lock()
	mock.calls.DeviceGetUtilizationRates = append(mock.calls.DeviceGetUtilizationRates, callInfo)
	mock.lockDeviceGetUtilizationRates.Unlock()
	return mock.DeviceGetUtilizationRatesFunc(device)
}

// DeviceGetUtilizationRatesCalls gets all the calls that were made to DeviceGetUtilizationRates.
// Check the length with:
//
//	len(mockedInterface.DeviceGetUtilizationRatesCalls())
func (mock *Interface) DeviceGetUtilizationRatesCalls() []struct {
	Device nvml.Device
} {
	var calls []struct {
		Device nvml.Device
	}
	mock.lockDeviceGetUtilizationRates.RLock()
	calls = mock.calls.DeviceGetUtilizationRates
	mock.lockDeviceGetUtilizationRates.RUnlock()
	return calls
}

// DeviceGetVbiosVersion calls DeviceGetVbiosVersionFunc.
func (mock *Interface) DeviceGetVbiosVersion(device nvml.Device) (string, nvml.Return) {
	if mock.DeviceGetVbiosVersionFunc == nil {
		panic("Interface.DeviceGetVbiosVersionFunc: method is nil but Interface.DeviceGetVbiosVersion was just called")
	}
	callInfo := struct {
		Device nvml.Device
	}{
		Device: device,
	}
	mock.lockDeviceGetVbiosVersion.Lock()
	mock.calls.DeviceGetVbiosVersion = append(mock.calls.DeviceGetVbiosVersion, callInfo)
	mock.lockDeviceGetVbiosVersion.Unlock()
	return mock.DeviceGetVbiosVersionFunc(device)
}

// DeviceGetVbiosVersionCalls gets all the calls that were made to DeviceGetVbiosVersion.
// Check the length with:
//
//	len(mockedInterface.DeviceGetVbiosVersionCalls())
func (mock *Interface) DeviceGetVbiosVersionCalls() []struct {
	Device nvml.Device
} {
	var calls []struct {
		Device nvml.Device
	}
	mock.lockDeviceGetVbiosVersion.RLock()
	calls = mock.calls.DeviceGetVbiosVersion
	mock.lockDeviceGetVbiosVersion.RUnlock()
	return calls
}

// DeviceGetVgpuCapabilities calls DeviceGetVgpuCapabilitiesFunc.
func (mock *Interface) DeviceGetVgpuCapabilities(device nvml.Device, deviceVgpuCapability nvml.DeviceVgpuCapability) (bool, nvml.Return) {
	if mock.DeviceGetVgpuCapabilitiesFunc == nil {
		panic("Interface.DeviceGetVgpuCapabilitiesFunc: method is nil but Interface.DeviceGetVgpuCapabilities was just called")
	}
	callInfo := struct {
		Device               nvml.Device
		DeviceVgpuCapability nvml.DeviceVgpuCapability
	}{
		Device:               device,
		DeviceVgpuCapability: deviceVgpuCapability,
	}
	mock.lockDeviceGetVgpuCapabilities.Lock()
	mock.calls.DeviceGetVgpuCapabilities = append(mock.calls.DeviceGetVgpuCapabilities, callInfo)
	mock.lockDeviceGetVgpuCapabilities.Unlock()
	return mock.DeviceGetVgpuCapabilitiesFunc(device, deviceVgpuCapability)
}

// DeviceGetVgpuCapabilitiesCalls gets all the calls that were made to DeviceGetVgpuCapabilities.
// Check the length with:
//
//	len(mockedInterface.DeviceGetVgpuCapabilitiesCalls())
func (mock *Interface) DeviceGetVgpuCapabilitiesCalls() []struct {
	Device               nvml.Device
	DeviceVgpuCapability nvml.DeviceVgpuCapability
} {
	var calls []struct {
		Device               nvml.Device
		DeviceVgpuCapability nvml.DeviceVgpuCapability
	}
	mock.lockDeviceGetVgpuCapabilities.RLock()
	calls = mock.calls.DeviceGetVgpuCapabilities
	mock.lockDeviceGetVgpuCapabilities.RUnlock()
	return calls
}

// DeviceGetVgpuHeterogeneousMode calls DeviceGetVgpuHeterogeneousModeFunc.
func (mock *Interface) DeviceGetVgpuHeterogeneousMode(device nvml.Device) (nvml.VgpuHeterogeneousMode, nvml.Return) {
	if mock.DeviceGetVgpuHeterogeneousModeFunc == nil {
		panic("Interface.DeviceGetVgpuHeterogeneousModeFunc: method is nil but Interface.DeviceGetVgpuHeterogeneousMode was just called")
	}
	callInfo := struct {
		Device nvml.Device
	}{
		Device: device,
	}
	mock.lockDeviceGetVgpuHeterogeneousMode.Lock()
	mock.calls.DeviceGetVgpuHeterogeneousMode = append(mock.calls.DeviceGetVgpuHeterogeneousMode, callInfo)
	mock.lockDeviceGetVgpuHeterogeneousMode.Unlock()
	return mock.DeviceGetVgpuHeterogeneousModeFunc(device)
}

// DeviceGetVgpuHeterogeneousModeCalls gets all the calls that were made to DeviceGetVgpuHeterogeneousMode.
// Check the length with:
//
//	len(mockedInterface.DeviceGetVgpuHeterogeneousModeCalls())
func (mock *Interface) DeviceGetVgpuHeterogeneousModeCalls() []struct {
	Device nvml.Device
} {
	var calls []struct {
		Device nvml.Device
	}
	mock.lockDeviceGetVgpuHeterogeneousMode.RLock()
	calls = mock.calls.DeviceGetVgpuHeterogeneousMode
	mock.lockDeviceGetVgpuHeterogeneousMode.RUnlock()
	return calls
}

// DeviceGetVgpuInstancesUtilizationInfo calls DeviceGetVgpuInstancesUtilizationInfoFunc.
func (mock *Interface) DeviceGetVgpuInstancesUtilizationInfo(device nvml.Device) (nvml.VgpuInstancesUtilizationInfo, nvml.Return) {
	if mock.DeviceGetVgpuInstancesUtilizationInfoFunc == nil {
		panic("Interface.DeviceGetVgpuInstancesUtilizationInfoFunc: method is nil but Interface.DeviceGetVgpuInstancesUtilizationInfo was just called")
	}
	callInfo := struct {
		Device nvml.Device
	}{
		Device: device,
	}
	mock.lockDeviceGetVgpuInstancesUtilizationInfo.Lock()
	mock.calls.DeviceGetVgpuInstancesUtilizationInfo = append(mock.calls.DeviceGetVgpuInstancesUtilizationInfo, callInfo)
	mock.lockDeviceGetVgpuInstancesUtilizationInfo.Unlock()
	return mock.DeviceGetVgpuInstancesUtilizationInfoFunc(device)
}

// DeviceGetVgpuInstancesUtilizationInfoCalls gets all the calls that were made to DeviceGetVgpuInstancesUtilizationInfo.
// Check the length with:
//
//	len(mockedInterface.DeviceGetVgpuInstancesUtilizationInfoCalls())
func (mock *Interface) DeviceGetVgpuInstancesUtilizationInfoCalls() []struct {
	Device nvml.Device
} {
	var calls []struct {
		Device nvml.Device
	}
	mock.lockDeviceGetVgpuInstancesUtilizationInfo.RLock()
	calls = mock.calls.DeviceGetVgpuInstancesUtilizationInfo
	mock.lockDeviceGetVgpuInstancesUtilizationInfo.RUnlock()
	return calls
}

// DeviceGetVgpuMetadata calls DeviceGetVgpuMetadataFunc.
func (mock *Interface) DeviceGetVgpuMetadata(device nvml.Device) (nvml.VgpuPgpuMetadata, nvml.Return) {
	if mock.DeviceGetVgpuMetadataFunc == nil {
		panic("Interface.DeviceGetVgpuMetadataFunc: method is nil but Interface.DeviceGetVgpuMetadata was just called")
	}
	callInfo := struct {
		Device nvml.Device
	}{
		Device: device,
	}
	mock.lockDeviceGetVgpuMetadata.Lock()
	mock.calls.DeviceGetVgpuMetadata = append(mock.calls.DeviceGetVgpuMetadata, callInfo)
	mock.lockDeviceGetVgpuMetadata.Unlock()
	return mock.DeviceGetVgpuMetadataFunc(device)
}

// DeviceGetVgpuMetadataCalls gets all the calls that were made to DeviceGetVgpuMetadata.
// Check the length with:
//
//	len(mockedInterface.DeviceGetVgpuMetadataCalls())
func (mock *Interface) DeviceGetVgpuMetadataCalls() []struct {
	Device nvml.Device
} {
	var calls []struct {
		Device nvml.Device
	}
	mock.lockDeviceGetVgpuMetadata.RLock()
	calls = mock.calls.DeviceGetVgpuMetadata
	mock.lockDeviceGetVgpuMetadata.RUnlock()
	return calls
}

// DeviceGetVgpuProcessUtilization calls DeviceGetVgpuProcessUtilizationFunc.
func (mock *Interface) DeviceGetVgpuProcessUtilization(device nvml.Device, v uint64) ([]nvml.VgpuProcessUtilizationSample, nvml.Return) {
	if mock.DeviceGetVgpuProcessUtilizationFunc == nil {
		panic("Interface.DeviceGetVgpuProcessUtilizationFunc: method is nil but Interface.DeviceGetVgpuProcessUtilization was just called")
	}
	callInfo := struct {
		Device nvml.Device
		V      uint64
	}{
		Device: device,
		V:      v,
	}
	mock.lockDeviceGetVgpuProcessUtilization.Lock()
	mock.calls.DeviceGetVgpuProcessUtilization = append(mock.calls.DeviceGetVgpuProcessUtilization, callInfo)
	mock.lockDeviceGetVgpuProcessUtilization.Unlock()
	return mock.DeviceGetVgpuProcessUtilizationFunc(device, v)
}

// DeviceGetVgpuProcessUtilizationCalls gets all the calls that were made to DeviceGetVgpuProcessUtilization.
// Check the length with:
//
//	len(mockedInterface.DeviceGetVgpuProcessUtilizationCalls())
func (mock *Interface) DeviceGetVgpuProcessUtilizationCalls() []struct {
	Device nvml.Device
	V      uint64
} {
	var calls []struct {
		Device nvml.Device
		V      uint64
	}
	mock.lockDeviceGetVgpuProcessUtilization.RLock()
	calls = mock.calls.DeviceGetVgpuProcessUtilization
	mock.lockDeviceGetVgpuProcessUtilization.RUnlock()
	return calls
}

// DeviceGetVgpuProcessesUtilizationInfo calls DeviceGetVgpuProcessesUtilizationInfoFunc.
func (mock *Interface) DeviceGetVgpuProcessesUtilizationInfo(device nvml.Device) (nvml.VgpuProcessesUtilizationInfo, nvml.Return) {
	if mock.DeviceGetVgpuProcessesUtilizationInfoFunc == nil {
		panic("Interface.DeviceGetVgpuProcessesUtilizationInfoFunc: method is nil but Interface.DeviceGetVgpuProcessesUtilizationInfo was just called")
	}
	callInfo := struct {
		Device nvml.Device
	}{
		Device: device,
	}
	mock.lockDeviceGetVgpuProcessesUtilizationInfo.Lock()
	mock.calls.DeviceGetVgpuProcessesUtilizationInfo = append(mock.calls.DeviceGetVgpuProcessesUtilizationInfo, callInfo)
	mock.lockDeviceGetVgpuProcessesUtilizationInfo.Unlock()
	return mock.DeviceGetVgpuProcessesUtilizationInfoFunc(device)
}

// DeviceGetVgpuProcessesUtilizationInfoCalls gets all the calls that were made to DeviceGetVgpuProcessesUtilizationInfo.
// Check the length with:
//
//	len(mockedInterface.DeviceGetVgpuProcessesUtilizationInfoCalls())
func (mock *Interface) DeviceGetVgpuProcessesUtilizationInfoCalls() []struct {
	Device nvml.Device
} {
	var calls []struct {
		Device nvml.Device
	}
	mock.lockDeviceGetVgpuProcessesUtilizationInfo.RLock()
	calls = mock.calls.DeviceGetVgpuProcessesUtilizationInfo
	mock.lockDeviceGetVgpuProcessesUtilizationInfo.RUnlock()
	return calls
}

// DeviceGetVgpuSchedulerCapabilities calls DeviceGetVgpuSchedulerCapabilitiesFunc.
func (mock *Interface) DeviceGetVgpuSchedulerCapabilities(device nvml.Device) (nvml.VgpuSchedulerCapabilities, nvml.Return) {
	if mock.DeviceGetVgpuSchedulerCapabilitiesFunc == nil {
		panic("Interface.DeviceGetVgpuSchedulerCapabilitiesFunc: method is nil but Interface.DeviceGetVgpuSchedulerCapabilities was just called")
	}
	callInfo := struct {
		Device nvml.Device
	}{
		Device: device,
	}
	mock.lockDeviceGetVgpuSchedulerCapabilities.Lock()
	mock.calls.DeviceGetVgpuSchedulerCapabilities = append(mock.calls.DeviceGetVgpuSchedulerCapabilities, callInfo)
	mock.lockDeviceGetVgpuSchedulerCapabilities.Unlock()
	return mock.DeviceGetVgpuSchedulerCapabilitiesFunc(device)
}

// DeviceGetVgpuSchedulerCapabilitiesCalls gets all the calls that were made to DeviceGetVgpuSchedulerCapabilities.
// Check the length with:
//
//	len(mockedInterface.DeviceGetVgpuSchedulerCapabilitiesCalls())
func (mock *Interface) DeviceGetVgpuSchedulerCapabilitiesCalls() []struct {
	Device nvml.Device
} {
	var calls []struct {
		Device nvml.Device
	}
	mock.lockDeviceGetVgpuSchedulerCapabilities.RLock()
	calls = mock.calls.DeviceGetVgpuSchedulerCapabilities
	mock.lockDeviceGetVgpuSchedulerCapabilities.RUnlock()
	return calls
}

// DeviceGetVgpuSchedulerLog calls DeviceGetVgpuSchedulerLogFunc.
func (mock *Interface) DeviceGetVgpuSchedulerLog(device nvml.Device) (nvml.VgpuSchedulerLog, nvml.Return) {
	if mock.DeviceGetVgpuSchedulerLogFunc == nil {
		panic("Interface.DeviceGetVgpuSchedulerLogFunc: method is nil but Interface.DeviceGetVgpuSchedulerLog was just called")
	}
	callInfo := struct {
		Device nvml.Device
	}{
		Device: device,
	}
	mock.lockDeviceGetVgpuSchedulerLog.Lock()
	mock.calls.DeviceGetVgpuSchedulerLog = append(mock.calls.DeviceGetVgpuSchedulerLog, callInfo)
	mock.lockDeviceGetVgpuSchedulerLog.Unlock()
	return mock.DeviceGetVgpuSchedulerLogFunc(device)
}

// DeviceGetVgpuSchedulerLogCalls gets all the calls that were made to DeviceGetVgpuSchedulerLog.
// Check the length with:
//
//	len(mockedInterface.DeviceGetVgpuSchedulerLogCalls())
func (mock *Interface) DeviceGetVgpuSchedulerLogCalls() []struct {
	Device nvml.Device
} {
	var calls []struct {
		Device nvml.Device
	}
	mock.lockDeviceGetVgpuSchedulerLog.RLock()
	calls = mock.calls.DeviceGetVgpuSchedulerLog
	mock.lockDeviceGetVgpuSchedulerLog.RUnlock()
	return calls
}

// DeviceGetVgpuSchedulerState calls DeviceGetVgpuSchedulerStateFunc.
func (mock *Interface) DeviceGetVgpuSchedulerState(device nvml.Device) (nvml.VgpuSchedulerGetState, nvml.Return) {
	if mock.DeviceGetVgpuSchedulerStateFunc == nil {
		panic("Interface.DeviceGetVgpuSchedulerStateFunc: method is nil but Interface.DeviceGetVgpuSchedulerState was just called")
	}
	callInfo := struct {
		Device nvml.Device
	}{
		Device: device,
	}
	mock.lockDeviceGetVgpuSchedulerState.Lock()
	mock.calls.DeviceGetVgpuSchedulerState = append(mock.calls.DeviceGetVgpuSchedulerState, callInfo)
	mock.lockDeviceGetVgpuSchedulerState.Unlock()
	return mock.DeviceGetVgpuSchedulerStateFunc(device)
}

// DeviceGetVgpuSchedulerStateCalls gets all the calls that were made to DeviceGetVgpuSchedulerState.
// Check the length with:
//
//	len(mockedInterface.DeviceGetVgpuSchedulerStateCalls())
func (mock *Interface) DeviceGetVgpuSchedulerStateCalls() []struct {
	Device nvml.Device
} {
	var calls []struct {
		Device nvml.Device
	}
	mock.lockDeviceGetVgpuSchedulerState.RLock()
	calls = mock.calls.DeviceGetVgpuSchedulerState
	mock.lockDeviceGetVgpuSchedulerState.RUnlock()
	return calls
}

// DeviceGetVgpuTypeCreatablePlacements calls DeviceGetVgpuTypeCreatablePlacementsFunc.
func (mock *Interface) DeviceGetVgpuTypeCreatablePlacements(device nvml.Device, vgpuTypeId nvml.VgpuTypeId) (nvml.VgpuPlacementList, nvml.Return) {
	if mock.DeviceGetVgpuTypeCreatablePlacementsFunc == nil {
		panic("Interface.DeviceGetVgpuTypeCreatablePlacementsFunc: method is nil but Interface.DeviceGetVgpuTypeCreatablePlacements was just called")
	}
	callInfo := struct {
		Device     nvml.Device
		VgpuTypeId nvml.VgpuTypeId
	}{
		Device:     device,
		VgpuTypeId: vgpuTypeId,
	}
	mock.lockDeviceGetVgpuTypeCreatablePlacements.Lock()
	mock.calls.DeviceGetVgpuTypeCreatablePlacements = append(mock.calls.DeviceGetVgpuTypeCreatablePlacements, callInfo)
	mock.lockDeviceGetVgpuTypeCreatablePlacements.Unlock()
	return mock.DeviceGetVgpuTypeCreatablePlacementsFunc(device, vgpuTypeId)
}

// DeviceGetVgpuTypeCreatablePlacementsCalls gets all the calls that were made to DeviceGetVgpuTypeCreatablePlacements.
// Check the length with:
//
//	len(mockedInterface.DeviceGetVgpuTypeCreatablePlacementsCalls())
func (mock *Interface) DeviceGetVgpuTypeCreatablePlacementsCalls() []struct {
	Device     nvml.Device
	VgpuTypeId nvml.VgpuTypeId
} {
	var calls []struct {
		Device     nvml.Device
		VgpuTypeId nvml.VgpuTypeId
	}
	mock.lockDeviceGetVgpuTypeCreatablePlacements.RLock()
	calls = mock.calls.DeviceGetVgpuTypeCreatablePlacements
	mock.lockDeviceGetVgpuTypeCreatablePlacements.RUnlock()
	return calls
}

// DeviceGetVgpuTypeSupportedPlacements calls DeviceGetVgpuTypeSupportedPlacementsFunc.
func (mock *Interface) DeviceGetVgpuTypeSupportedPlacements(device nvml.Device, vgpuTypeId nvml.VgpuTypeId) (nvml.VgpuPlacementList, nvml.Return) {
	if mock.DeviceGetVgpuTypeSupportedPlacementsFunc == nil {
		panic("Interface.DeviceGetVgpuTypeSupportedPlacementsFunc: method is nil but Interface.DeviceGetVgpuTypeSupportedPlacements was just called")
	}
	callInfo := struct {
		Device     nvml.Device
		VgpuTypeId nvml.VgpuTypeId
	}{
		Device:     device,
		VgpuTypeId: vgpuTypeId,
	}
	mock.lockDeviceGetVgpuTypeSupportedPlacements.Lock()
	mock.calls.DeviceGetVgpuTypeSupportedPlacements = append(mock.calls.DeviceGetVgpuTypeSupportedPlacements, callInfo)
	mock.lockDeviceGetVgpuTypeSupportedPlacements.Unlock()
	return mock.DeviceGetVgpuTypeSupportedPlacementsFunc(device, vgpuTypeId)
}

// DeviceGetVgpuTypeSupportedPlacementsCalls gets all the calls that were made to DeviceGetVgpuTypeSupportedPlacements.
// Check the length with:
//
//	len(mockedInterface.DeviceGetVgpuTypeSupportedPlacementsCalls())
func (mock *Interface) DeviceGetVgpuTypeSupportedPlacementsCalls() []struct {
	Device     nvml.Device
	VgpuTypeId nvml.VgpuTypeId
} {
	var calls []struct {
		Device     nvml.Device
		VgpuTypeId nvml.VgpuTypeId
	}
	mock.lockDeviceGetVgpuTypeSupportedPlacements.RLock()
	calls = mock.calls.DeviceGetVgpuTypeSupportedPlacements
	mock.lockDeviceGetVgpuTypeSupportedPlacements.RUnlock()
	return calls
}

// DeviceGetVgpuUtilization calls DeviceGetVgpuUtilizationFunc.
func (mock *Interface) DeviceGetVgpuUtilization(device nvml.Device, v uint64) (nvml.ValueType, []nvml.VgpuInstanceUtilizationSample, nvml.Return) {
	if mock.DeviceGetVgpuUtilizationFunc == nil {
		panic("Interface.DeviceGetVgpuUtilizationFunc: method is nil but Interface.DeviceGetVgpuUtilization was just called")
	}
	callInfo := struct {
		Device nvml.Device
		V      uint64
	}{
		Device: device,
		V:      v,
	}
	mock.lockDeviceGetVgpuUtilization.Lock()
	mock.calls.DeviceGetVgpuUtilization = append(mock.calls.DeviceGetVgpuUtilization, callInfo)
	mock.lockDeviceGetVgpuUtilization.Unlock()
	return mock.DeviceGetVgpuUtilizationFunc(device, v)
}

// DeviceGetVgpuUtilizationCalls gets all the calls that were made to DeviceGetVgpuUtilization.
// Check the length with:
//
//	len(mockedInterface.DeviceGetVgpuUtilizationCalls())
func (mock *Interface) DeviceGetVgpuUtilizationCalls() []struct {
	Device nvml.Device
	V      uint64
} {
	var calls []struct {
		Device nvml.Device
		V      uint64
	}
	mock.lockDeviceGetVgpuUtilization.RLock()
	calls = mock.calls.DeviceGetVgpuUtilization
	mock.lockDeviceGetVgpuUtilization.RUnlock()
	return calls
}

// DeviceGetViolationStatus calls DeviceGetViolationStatusFunc.
func (mock *Interface) DeviceGetViolationStatus(device nvml.Device, perfPolicyType nvml.PerfPolicyType) (nvml.ViolationTime, nvml.Return) {
	if mock.DeviceGetViolationStatusFunc == nil {
		panic("Interface.DeviceGetViolationStatusFunc: method is nil but Interface.DeviceGetViolationStatus was just called")
	}
	callInfo := struct {
		Device         nvml.Device
		PerfPolicyType nvml.PerfPolicyType
	}{
		Device:         device,
		PerfPolicyType: perfPolicyType,
	}
	mock.lockDeviceGetViolationStatus.Lock()
	mock.calls.DeviceGetViolationStatus = append(mock.calls.DeviceGetViolationStatus, callInfo)
	mock.lockDeviceGetViolationStatus.Unlock()
	return mock.DeviceGetViolationStatusFunc(device, perfPolicyType)
}

// DeviceGetViolationStatusCalls gets all the calls that were made to DeviceGetViolationStatus.
// Check the length with:
//
//	len(mockedInterface.DeviceGetViolationStatusCalls())
func (mock *Interface) DeviceGetViolationStatusCalls() []struct {
	Device         nvml.Device
	PerfPolicyType nvml.PerfPolicyType
} {
	var calls []struct {
		Device         nvml.Device
		PerfPolicyType nvml.PerfPolicyType
	}
	mock.lockDeviceGetViolationStatus.RLock()
	calls = mock.calls.DeviceGetViolationStatus
	mock.lockDeviceGetViolationStatus.RUnlock()
	return calls
}

// DeviceGetVirtualizationMode calls DeviceGetVirtualizationModeFunc.
func (mock *Interface) DeviceGetVirtualizationMode(device nvml.Device) (nvml.GpuVirtualizationMode, nvml.Return) {
	if mock.DeviceGetVirtualizationModeFunc == nil {
		panic("Interface.DeviceGetVirtualizationModeFunc: method is nil but Interface.DeviceGetVirtualizationMode was just called")
	}
	callInfo := struct {
		Device nvml.Device
	}{
		Device: device,
	}
	mock.lockDeviceGetVirtualizationMode.Lock()
	mock.calls.DeviceGetVirtualizationMode = append(mock.calls.DeviceGetVirtualizationMode, callInfo)
	mock.lockDeviceGetVirtualizationMode.Unlock()
	return mock.DeviceGetVirtualizationModeFunc(device)
}

// DeviceGetVirtualizationModeCalls gets all the calls that were made to DeviceGetVirtualizationMode.
// Check the length with:
//
//	len(mockedInterface.DeviceGetVirtualizationModeCalls())
func (mock *Interface) DeviceGetVirtualizationModeCalls() []struct {
	Device nvml.Device
} {
	var calls []struct {
		Device nvml.Device
	}
	mock.lockDeviceGetVirtualizationMode.RLock()
	calls = mock.calls.DeviceGetVirtualizationMode
	mock.lockDeviceGetVirtualizationMode.RUnlock()
	return calls
}

// DeviceIsMigDeviceHandle calls DeviceIsMigDeviceHandleFunc.
func (mock *Interface) DeviceIsMigDeviceHandle(device nvml.Device) (bool, nvml.Return) {
	if mock.DeviceIsMigDeviceHandleFunc == nil {
		panic("Interface.DeviceIsMigDeviceHandleFunc: method is nil but Interface.DeviceIsMigDeviceHandle was just called")
	}
	callInfo := struct {
		Device nvml.Device
	}{
		Device: device,
	}
	mock.lockDeviceIsMigDeviceHandle.Lock()
	mock.calls.DeviceIsMigDeviceHandle = append(mock.calls.DeviceIsMigDeviceHandle, callInfo)
	mock.lockDeviceIsMigDeviceHandle.Unlock()
	return mock.DeviceIsMigDeviceHandleFunc(device)
}

// DeviceIsMigDeviceHandleCalls gets all the calls that were made to DeviceIsMigDeviceHandle.
// Check the length with:
//
//	len(mockedInterface.DeviceIsMigDeviceHandleCalls())
func (mock *Interface) DeviceIsMigDeviceHandleCalls() []struct {
	Device nvml.Device
} {
	var calls []struct {
		Device nvml.Device
	}
	mock.lockDeviceIsMigDeviceHandle.RLock()
	calls = mock.calls.DeviceIsMigDeviceHandle
	mock.lockDeviceIsMigDeviceHandle.RUnlock()
	return calls
}

// DeviceModifyDrainState calls DeviceModifyDrainStateFunc.
func (mock *Interface) DeviceModifyDrainState(pciInfo *nvml.PciInfo, enableState nvml.EnableState) nvml.Return {
	if mock.DeviceModifyDrainStateFunc == nil {
		panic("Interface.DeviceModifyDrainStateFunc: method is nil but Interface.DeviceModifyDrainState was just called")
	}
	callInfo := struct {
		PciInfo     *nvml.PciInfo
		EnableState nvml.EnableState
	}{
		PciInfo:     pciInfo,
		EnableState: enableState,
	}
	mock.lockDeviceModifyDrainState.Lock()
	mock.calls.DeviceModifyDrainState = append(mock.calls.DeviceModifyDrainState, callInfo)
	mock.lockDeviceModifyDrainState.Unlock()
	return mock.DeviceModifyDrainStateFunc(pciInfo, enableState)
}

// DeviceModifyDrainStateCalls gets all the calls that were made to DeviceModifyDrainState.
// Check the length with:
//
//	len(mockedInterface.DeviceModifyDrainStateCalls())
func (mock *Interface) DeviceModifyDrainStateCalls() []struct {
	PciInfo     *nvml.PciInfo
	EnableState nvml.EnableState
} {
	var calls []struct {
		PciInfo     *nvml.PciInfo
		EnableState nvml.EnableState
	}
	mock.lockDeviceModifyDrainState.RLock()
	calls = mock.calls.DeviceModifyDrainState
	mock.lockDeviceModifyDrainState.RUnlock()
	return calls
}

// DeviceOnSameBoard calls DeviceOnSameBoardFunc.
func (mock *Interface) DeviceOnSameBoard(device1 nvml.Device, device2 nvml.Device) (int, nvml.Return) {
	if mock.DeviceOnSameBoardFunc == nil {
		panic("Interface.DeviceOnSameBoardFunc: method is nil but Interface.DeviceOnSameBoard was just called")
	}
	callInfo := struct {
		Device1 nvml.Device
		Device2 nvml.Device
	}{
		Device1: device1,
		Device2: device2,
	}
	mock.lockDeviceOnSameBoard.Lock()
	mock.calls.DeviceOnSameBoard = append(mock.calls.DeviceOnSameBoard, callInfo)
	mock.lockDeviceOnSameBoard.Unlock()
	return mock.DeviceOnSameBoardFunc(device1, device2)
}

// DeviceOnSameBoardCalls gets all the calls that were made to DeviceOnSameBoard.
// Check the length with:
//
//	len(mockedInterface.DeviceOnSameBoardCalls())
func (mock *Interface) DeviceOnSameBoardCalls() []struct {
	Device1 nvml.Device
	Device2 nvml.Device
} {
	var calls []struct {
		Device1 nvml.Device
		Device2 nvml.Device
	}
	mock.lockDeviceOnSameBoard.RLock()
	calls = mock.calls.DeviceOnSameBoard
	mock.lockDeviceOnSameBoard.RUnlock()
	return calls
}

// DevicePowerSmoothingActivatePresetProfile calls DevicePowerSmoothingActivatePresetProfileFunc.
func (mock *Interface) DevicePowerSmoothingActivatePresetProfile(device nvml.Device, powerSmoothingProfile *nvml.PowerSmoothingProfile) nvml.Return {
	if mock.DevicePowerSmoothingActivatePresetProfileFunc == nil {
		panic("Interface.DevicePowerSmoothingActivatePresetProfileFunc: method is nil but Interface.DevicePowerSmoothingActivatePresetProfile was just called")
	}
	callInfo := struct {
		Device                nvml.Device
		PowerSmoothingProfile *nvml.PowerSmoothingProfile
	}{
		Device:                device,
		PowerSmoothingProfile: powerSmoothingProfile,
	}
	mock.lockDevicePowerSmoothingActivatePresetProfile.Lock()
	mock.calls.DevicePowerSmoothingActivatePresetProfile = append(mock.calls.DevicePowerSmoothingActivatePresetProfile, callInfo)
	mock.lockDevicePowerSmoothingActivatePresetProfile.Unlock()
	return mock.DevicePowerSmoothingActivatePresetProfileFunc(device, powerSmoothingProfile)
}

// DevicePowerSmoothingActivatePresetProfileCalls gets all the calls that were made to DevicePowerSmoothingActivatePresetProfile.
// Check the length with:
//
//	len(mockedInterface.DevicePowerSmoothingActivatePresetProfileCalls())
func (mock *Interface) DevicePowerSmoothingActivatePresetProfileCalls() []struct {
	Device                nvml.Device
	PowerSmoothingProfile *nvml.PowerSmoothingProfile
} {
	var calls []struct {
		Device                nvml.Device
		PowerSmoothingProfile *nvml.PowerSmoothingProfile
	}
	mock.lockDevicePowerSmoothingActivatePresetProfile.RLock()
	calls = mock.calls.DevicePowerSmoothingActivatePresetProfile
	mock.lockDevicePowerSmoothingActivatePresetProfile.RUnlock()
	return calls
}

// DevicePowerSmoothingSetState calls DevicePowerSmoothingSetStateFunc.
func (mock *Interface) DevicePowerSmoothingSetState(device nvml.Device, powerSmoothingState *nvml.PowerSmoothingState) nvml.Return {
	if mock.DevicePowerSmoothingSetStateFunc == nil {
		panic("Interface.DevicePowerSmoothingSetStateFunc: method is nil but Interface.DevicePowerSmoothingSetState was just called")
	}
	callInfo := struct {
		Device              nvml.Device
		PowerSmoothingState *nvml.PowerSmoothingState
	}{
		Device:              device,
		PowerSmoothingState: powerSmoothingState,
	}
	mock.lockDevicePowerSmoothingSetState.Lock()
	mock.calls.DevicePowerSmoothingSetState = append(mock.calls.DevicePowerSmoothingSetState, callInfo)
	mock.lockDevicePowerSmoothingSetState.Unlock()
	return mock.DevicePowerSmoothingSetStateFunc(device, powerSmoothingState)
}

// DevicePowerSmoothingSetStateCalls gets all the calls that were made to DevicePowerSmoothingSetState.
// Check the length with:
//
//	len(mockedInterface.DevicePowerSmoothingSetStateCalls())
func (mock *Interface) DevicePowerSmoothingSetStateCalls() []struct {
	Device              nvml.Device
	PowerSmoothingState *nvml.PowerSmoothingState
} {
	var calls []struct {
		Device              nvml.Device
		PowerSmoothingState *nvml.PowerSmoothingState
	}
	mock.lockDevicePowerSmoothingSetState.RLock()
	calls = mock.calls.DevicePowerSmoothingSetState
	mock.lockDevicePowerSmoothingSetState.RUnlock()
	return calls
}

// DevicePowerSmoothingUpdatePresetProfileParam calls DevicePowerSmoothingUpdatePresetProfileParamFunc.
func (mock *Interface) DevicePowerSmoothingUpdatePresetProfileParam(device nvml.Device, powerSmoothingProfile *nvml.PowerSmoothingProfile) nvml.Return {
	if mock.DevicePowerSmoothingUpdatePresetProfileParamFunc == nil {
		panic("Interface.DevicePowerSmoothingUpdatePresetProfileParamFunc: method is nil but Interface.DevicePowerSmoothingUpdatePresetProfileParam was just called")
	}
	callInfo := struct {
		Device                nvml.Device
		PowerSmoothingProfile *nvml.PowerSmoothingProfile
	}{
		Device:                device,
		PowerSmoothingProfile: powerSmoothingProfile,
	}
	mock.lockDevicePowerSmoothingUpdatePresetProfileParam.Lock()
	mock.calls.DevicePowerSmoothingUpdatePresetProfileParam = append(mock.calls.DevicePowerSmoothingUpdatePresetProfileParam, callInfo)
	mock.lockDevicePowerSmoothingUpdatePresetProfileParam.Unlock()
	return mock.DevicePowerSmoothingUpdatePresetProfileParamFunc(device, powerSmoothingProfile)
}

// DevicePowerSmoothingUpdatePresetProfileParamCalls gets all the calls that were made to DevicePowerSmoothingUpdatePresetProfileParam.
// Check the length with:
//
//	len(mockedInterface.DevicePowerSmoothingUpdatePresetProfileParamCalls())
func (mock *Interface) DevicePowerSmoothingUpdatePresetProfileParamCalls() []struct {
	Device                nvml.Device
	PowerSmoothingProfile *nvml.PowerSmoothingProfile
} {
	var calls []struct {
		Device                nvml.Device
		PowerSmoothingProfile *nvml.PowerSmoothingProfile
	}
	mock.lockDevicePowerSmoothingUpdatePresetProfileParam.RLock()
	calls = mock.calls.DevicePowerSmoothingUpdatePresetProfileParam
	mock.lockDevicePowerSmoothingUpdatePresetProfileParam.RUnlock()
	return calls
}

// DeviceQueryDrainState calls DeviceQueryDrainStateFunc.
func (mock *Interface) DeviceQueryDrainState(pciInfo *nvml.PciInfo) (nvml.EnableState, nvml.Return) {
	if mock.DeviceQueryDrainStateFunc == nil {
		panic("Interface.DeviceQueryDrainStateFunc: method is nil but Interface.DeviceQueryDrainState was just called")
	}
	callInfo := struct {
		PciInfo *nvml.PciInfo
	}{
		PciInfo: pciInfo,
	}
	mock.lockDeviceQueryDrainState.Lock()
	mock.calls.DeviceQueryDrainState = append(mock.calls.DeviceQueryDrainState, callInfo)
	mock.lockDeviceQueryDrainState.Unlock()
	return mock.DeviceQueryDrainStateFunc(pciInfo)
}

// DeviceQueryDrainStateCalls gets all the calls that were made to DeviceQueryDrainState.
// Check the length with:
//
//	len(mockedInterface.DeviceQueryDrainStateCalls())
func (mock *Interface) DeviceQueryDrainStateCalls() []struct {
	PciInfo *nvml.PciInfo
} {
	var calls []struct {
		PciInfo *nvml.PciInfo
	}
	mock.lockDeviceQueryDrainState.RLock()
	calls = mock.calls.DeviceQueryDrainState
	mock.lockDeviceQueryDrainState.RUnlock()
	return calls
}

// DeviceReadWritePRM_v1 calls DeviceReadWritePRM_v1Func.
func (mock *Interface) DeviceReadWritePRM_v1(device nvml.Device, pRMTLV_v1 *nvml.PRMTLV_v1) nvml.Return {
	if mock.DeviceReadWritePRM_v1Func == nil {
		panic("Interface.DeviceReadWritePRM_v1Func: method is nil but Interface.DeviceReadWritePRM_v1 was just called")
	}
	callInfo := struct {
		Device    nvml.Device
		PRMTLV_v1 *nvml.PRMTLV_v1
	}{
		Device:    device,
		PRMTLV_v1: pRMTLV_v1,
	}
	mock.lockDeviceReadWritePRM_v1.Lock()
	mock.calls.DeviceReadWritePRM_v1 = append(mock.calls.DeviceReadWritePRM_v1, callInfo)
	mock.lockDeviceReadWritePRM_v1.Unlock()
	return mock.DeviceReadWritePRM_v1Func(device, pRMTLV_v1)
}

// DeviceReadWritePRM_v1Calls gets all the calls that were made to DeviceReadWritePRM_v1.
// Check the length with:
//
//	len(mockedInterface.DeviceReadWritePRM_v1Calls())
func (mock *Interface) DeviceReadWritePRM_v1Calls() []struct {
	Device    nvml.Device
	PRMTLV_v1 *nvml.PRMTLV_v1
} {
	var calls []struct {
		Device    nvml.Device
		PRMTLV_v1 *nvml.PRMTLV_v1
	}
	mock.lockDeviceReadWritePRM_v1.RLock()
	calls = mock.calls.DeviceReadWritePRM_v1
	mock.lockDeviceReadWritePRM_v1.RUnlock()
	return calls
}

// DeviceRegisterEvents calls DeviceRegisterEventsFunc.
func (mock *Interface) DeviceRegisterEvents(device nvml.Device, v uint64, eventSet nvml.EventSet) nvml.Return {
	if mock.DeviceRegisterEventsFunc == nil {
		panic("Interface.DeviceRegisterEventsFunc: method is nil but Interface.DeviceRegisterEvents was just called")
	}
	callInfo := struct {
		Device   nvml.Device
		V        uint64
		EventSet nvml.EventSet
	}{
		Device:   device,
		V:        v,
		EventSet: eventSet,
	}
	mock.lockDeviceRegisterEvents.Lock()
	mock.calls.DeviceRegisterEvents = append(mock.calls.DeviceRegisterEvents, callInfo)
	mock.lockDeviceRegisterEvents.Unlock()
	return mock.DeviceRegisterEventsFunc(device, v, eventSet)
}

// DeviceRegisterEventsCalls gets all the calls that were made to DeviceRegisterEvents.
// Check the length with:
//
//	len(mockedInterface.DeviceRegisterEventsCalls())
func (mock *Interface) DeviceRegisterEventsCalls() []struct {
	Device   nvml.Device
	V        uint64
	EventSet nvml.EventSet
} {
	var calls []struct {
		Device   nvml.Device
		V        uint64
		EventSet nvml.EventSet
	}
	mock.lockDeviceRegisterEvents.RLock()
	calls = mock.calls.DeviceRegisterEvents
	mock.lockDeviceRegisterEvents.RUnlock()
	return calls
}

// DeviceRemoveGpu calls DeviceRemoveGpuFunc.
func (mock *Interface) DeviceRemoveGpu(pciInfo *nvml.PciInfo) nvml.Return {
	if mock.DeviceRemoveGpuFunc == nil {
		panic("Interface.DeviceRemoveGpuFunc: method is nil but Interface.DeviceRemoveGpu was just called")
	}
	callInfo := struct {
		PciInfo *nvml.PciInfo
	}{
		PciInfo: pciInfo,
	}
	mock.lockDeviceRemoveGpu.Lock()
	mock.calls.DeviceRemoveGpu = append(mock.calls.DeviceRemoveGpu, callInfo)
	mock.lockDeviceRemoveGpu.Unlock()
	return mock.DeviceRemoveGpuFunc(pciInfo)
}

// DeviceRemoveGpuCalls gets all the calls that were made to DeviceRemoveGpu.
// Check the length with:
//
//	len(mockedInterface.DeviceRemoveGpuCalls())
func (mock *Interface) DeviceRemoveGpuCalls() []struct {
	PciInfo *nvml.PciInfo
} {
	var calls []struct {
		PciInfo *nvml.PciInfo
	}
	mock.lockDeviceRemoveGpu.RLock()
	calls = mock.calls.DeviceRemoveGpu
	mock.lockDeviceRemoveGpu.RUnlock()
	return calls
}

// DeviceRemoveGpu_v2 calls DeviceRemoveGpu_v2Func.
func (mock *Interface) DeviceRemoveGpu_v2(pciInfo *nvml.PciInfo, detachGpuState nvml.DetachGpuState, pcieLinkState nvml.PcieLinkState) nvml.Return {
	if mock.DeviceRemoveGpu_v2Func == nil {
		panic("Interface.DeviceRemoveGpu_v2Func: method is nil but Interface.DeviceRemoveGpu_v2 was just called")
	}
	callInfo := struct {
		PciInfo        *nvml.PciInfo
		DetachGpuState nvml.DetachGpuState
		PcieLinkState  nvml.PcieLinkState
	}{
		PciInfo:        pciInfo,
		DetachGpuState: detachGpuState,
		PcieLinkState:  pcieLinkState,
	}
	mock.lockDeviceRemoveGpu_v2.Lock()
	mock.calls.DeviceRemoveGpu_v2 = append(mock.calls.DeviceRemoveGpu_v2, callInfo)
	mock.lockDeviceRemoveGpu_v2.Unlock()
	return mock.DeviceRemoveGpu_v2Func(pciInfo, detachGpuState, pcieLinkState)
}

// DeviceRemoveGpu_v2Calls gets all the calls that were made to DeviceRemoveGpu_v2.
// Check the length with:
//
//	len(mockedInterface.DeviceRemoveGpu_v2Calls())
func (mock *Interface) DeviceRemoveGpu_v2Calls() []struct {
	PciInfo        *nvml.PciInfo
	DetachGpuState nvml.DetachGpuState
	PcieLinkState  nvml.PcieLinkState
} {
	var calls []struct {
		PciInfo        *nvml.PciInfo
		DetachGpuState nvml.DetachGpuState
		PcieLinkState  nvml.PcieLinkState
	}
	mock.lockDeviceRemoveGpu_v2.RLock()
	calls = mock.calls.DeviceRemoveGpu_v2
	mock.lockDeviceRemoveGpu_v2.RUnlock()
	return calls
}

// DeviceResetApplicationsClocks calls DeviceResetApplicationsClocksFunc.
func (mock *Interface) DeviceResetApplicationsClocks(device nvml.Device) nvml.Return {
	if mock.DeviceResetApplicationsClocksFunc == nil {
		panic("Interface.DeviceResetApplicationsClocksFunc: method is nil but Interface.DeviceResetApplicationsClocks was just called")
	}
	callInfo := struct {
		Device nvml.Device
	}{
		Device: device,
	}
	mock.lockDeviceResetApplicationsClocks.Lock()
	mock.calls.DeviceResetApplicationsClocks = append(mock.calls.DeviceResetApplicationsClocks, callInfo)
	mock.lockDeviceResetApplicationsClocks.Unlock()
	return mock.DeviceResetApplicationsClocksFunc(device)
}

// DeviceResetApplicationsClocksCalls gets all the calls that were made to DeviceResetApplicationsClocks.
// Check the length with:
//
//	len(mockedInterface.DeviceResetApplicationsClocksCalls())
func (mock *Interface) DeviceResetApplicationsClocksCalls() []struct {
	Device nvml.Device
} {
	var calls []struct {
		Device nvml.Device
	}
	mock.lockDeviceResetApplicationsClocks.RLock()
	calls = mock.calls.DeviceResetApplicationsClocks
	mock.lockDeviceResetApplicationsClocks.RUnlock()
	return calls
}

// DeviceResetGpuLockedClocks calls DeviceResetGpuLockedClocksFunc.
func (mock *Interface) DeviceResetGpuLockedClocks(device nvml.Device) nvml.Return {
	if mock.DeviceResetGpuLockedClocksFunc == nil {
		panic("Interface.DeviceResetGpuLockedClocksFunc: method is nil but Interface.DeviceResetGpuLockedClocks was just called")
	}
	callInfo := struct {
		Device nvml.Device
	}{
		Device: device,
	}
	mock.lockDeviceResetGpuLockedClocks.Lock()
	mock.calls.DeviceResetGpuLockedClocks = append(mock.calls.DeviceResetGpuLockedClocks, callInfo)
	mock.lockDeviceResetGpuLockedClocks.Unlock()
	return mock.DeviceResetGpuLockedClocksFunc(device)
}

// DeviceResetGpuLockedClocksCalls gets all the calls that were made to DeviceResetGpuLockedClocks.
// Check the length with:
//
//	len(mockedInterface.DeviceResetGpuLockedClocksCalls())
func (mock *Interface) DeviceResetGpuLockedClocksCalls() []struct {
	Device nvml.Device
} {
	var calls []struct {
		Device nvml.Device
	}
	mock.lockDeviceResetGpuLockedClocks.RLock()
	calls = mock.calls.DeviceResetGpuLockedClocks
	mock.lockDeviceResetGpuLockedClocks.RUnlock()
	return calls
}

// DeviceResetMemoryLockedClocks calls DeviceResetMemoryLockedClocksFunc.
func (mock *Interface) DeviceResetMemoryLockedClocks(device nvml.Device) nvml.Return {
	if mock.DeviceResetMemoryLockedClocksFunc == nil {
		panic("Interface.DeviceResetMemoryLockedClocksFunc: method is nil but Interface.DeviceResetMemoryLockedClocks was just called")
	}
	callInfo := struct {
		Device nvml.Device
	}{
		Device: device,
	}
	mock.lockDeviceResetMemoryLockedClocks.Lock()
	mock.calls.DeviceResetMemoryLockedClocks = append(mock.calls.DeviceResetMemoryLockedClocks, callInfo)
	mock.lockDeviceResetMemoryLockedClocks.Unlock()
	return mock.DeviceResetMemoryLockedClocksFunc(device)
}

// DeviceResetMemoryLockedClocksCalls gets all the calls that were made to DeviceResetMemoryLockedClocks.
// Check the length with:
//
//	len(mockedInterface.DeviceResetMemoryLockedClocksCalls())
func (mock *Interface) DeviceResetMemoryLockedClocksCalls() []struct {
	Device nvml.Device
} {
	var calls []struct {
		Device nvml.Device
	}
	mock.lockDeviceResetMemoryLockedClocks.RLock()
	calls = mock.calls.DeviceResetMemoryLockedClocks
	mock.lockDeviceResetMemoryLockedClocks.RUnlock()
	return calls
}

// DeviceResetNvLinkErrorCounters calls DeviceResetNvLinkErrorCountersFunc.
func (mock *Interface) DeviceResetNvLinkErrorCounters(device nvml.Device, n int) nvml.Return {
	if mock.DeviceResetNvLinkErrorCountersFunc == nil {
		panic("Interface.DeviceResetNvLinkErrorCountersFunc: method is nil but Interface.DeviceResetNvLinkErrorCounters was just called")
	}
	callInfo := struct {
		Device nvml.Device
		N      int
	}{
		Device: device,
		N:      n,
	}
	mock.lockDeviceResetNvLinkErrorCounters.Lock()
	mock.calls.DeviceResetNvLinkErrorCounters = append(mock.calls.DeviceResetNvLinkErrorCounters, callInfo)
	mock.lockDeviceResetNvLinkErrorCounters.Unlock()
	return mock.DeviceResetNvLinkErrorCountersFunc(device, n)
}

// DeviceResetNvLinkErrorCountersCalls gets all the calls that were made to DeviceResetNvLinkErrorCounters.
// Check the length with:
//
//	len(mockedInterface.DeviceResetNvLinkErrorCountersCalls())
func (mock *Interface) DeviceResetNvLinkErrorCountersCalls() []struct {
	Device nvml.Device
	N      int
} {
	var calls []struct {
		Device nvml.Device
		N      int
	}
	mock.lockDeviceResetNvLinkErrorCounters.RLock()
	calls = mock.calls.DeviceResetNvLinkErrorCounters
	mock.lockDeviceResetNvLinkErrorCounters.RUnlock()
	return calls
}

// DeviceResetNvLinkUtilizationCounter calls DeviceResetNvLinkUtilizationCounterFunc.
func (mock *Interface) DeviceResetNvLinkUtilizationCounter(device nvml.Device, n1 int, n2 int) nvml.Return {
	if mock.DeviceResetNvLinkUtilizationCounterFunc == nil {
		panic("Interface.DeviceResetNvLinkUtilizationCounterFunc: method is nil but Interface.DeviceResetNvLinkUtilizationCounter was just called")
	}
	callInfo := struct {
		Device nvml.Device
		N1     int
		N2     int
	}{
		Device: device,
		N1:     n1,
		N2:     n2,
	}
	mock.lockDeviceResetNvLinkUtilizationCounter.Lock()
	mock.calls.DeviceResetNvLinkUtilizationCounter = append(mock.calls.DeviceResetNvLinkUtilizationCounter, callInfo)
	mock.lockDeviceResetNvLinkUtilizationCounter.Unlock()
	return mock.DeviceResetNvLinkUtilizationCounterFunc(device, n1, n2)
}

// DeviceResetNvLinkUtilizationCounterCalls gets all the calls that were made to DeviceResetNvLinkUtilizationCounter.
// Check the length with:
//
//	len(mockedInterface.DeviceResetNvLinkUtilizationCounterCalls())
func (mock *Interface) DeviceResetNvLinkUtilizationCounterCalls() []struct {
	Device nvml.Device
	N1     int
	N2     int
} {
	var calls []struct {
		Device nvml.Device
		N1     int
		N2     int
	}
	mock.lockDeviceResetNvLinkUtilizationCounter.RLock()
	calls = mock.calls.DeviceResetNvLinkUtilizationCounter
	mock.lockDeviceResetNvLinkUtilizationCounter.RUnlock()
	return calls
}

// DeviceSetAPIRestriction calls DeviceSetAPIRestrictionFunc.
func (mock *Interface) DeviceSetAPIRestriction(device nvml.Device, restrictedAPI nvml.RestrictedAPI, enableState nvml.EnableState) nvml.Return {
	if mock.DeviceSetAPIRestrictionFunc == nil {
		panic("Interface.DeviceSetAPIRestrictionFunc: method is nil but Interface.DeviceSetAPIRestriction was just called")
	}
	callInfo := struct {
		Device        nvml.Device
		RestrictedAPI nvml.RestrictedAPI
		EnableState   nvml.EnableState
	}{
		Device:        device,
		RestrictedAPI: restrictedAPI,
		EnableState:   enableState,
	}
	mock.lockDeviceSetAPIRestriction.Lock()
	mock.calls.DeviceSetAPIRestriction = append(mock.calls.DeviceSetAPIRestriction, callInfo)
	mock.lockDeviceSetAPIRestriction.Unlock()
	return mock.DeviceSetAPIRestrictionFunc(device, restrictedAPI, enableState)
}

// DeviceSetAPIRestrictionCalls gets all the calls that were made to DeviceSetAPIRestriction.
// Check the length with:
//
//	len(mockedInterface.DeviceSetAPIRestrictionCalls())
func (mock *Interface) DeviceSetAPIRestrictionCalls() []struct {
	Device        nvml.Device
	RestrictedAPI nvml.RestrictedAPI
	EnableState   nvml.EnableState
} {
	var calls []struct {
		Device        nvml.Device
		RestrictedAPI nvml.RestrictedAPI
		EnableState   nvml.EnableState
	}
	mock.lockDeviceSetAPIRestriction.RLock()
	calls = mock.calls.DeviceSetAPIRestriction
	mock.lockDeviceSetAPIRestriction.RUnlock()
	return calls
}

// DeviceSetAccountingMode calls DeviceSetAccountingModeFunc.
func (mock *Interface) DeviceSetAccountingMode(device nvml.Device, enableState nvml.EnableState) nvml.Return {
	if mock.DeviceSetAccountingModeFunc == nil {
		panic("Interface.DeviceSetAccountingModeFunc: method is nil but Interface.DeviceSetAccountingMode was just called")
	}
	callInfo := struct {
		Device      nvml.Device
		EnableState nvml.EnableState
	}{
		Device:      device,
		EnableState: enableState,
	}
	mock.lockDeviceSetAccountingMode.Lock()
	mock.calls.DeviceSetAccountingMode = append(mock.calls.DeviceSetAccountingMode, callInfo)
	mock.lockDeviceSetAccountingMode.Unlock()
	return mock.DeviceSetAccountingModeFunc(device, enableState)
}

// DeviceSetAccountingModeCalls gets all the calls that were made to DeviceSetAccountingMode.
// Check the length with:
//
//	len(mockedInterface.DeviceSetAccountingModeCalls())
func (mock *Interface) DeviceSetAccountingModeCalls() []struct {
	Device      nvml.Device
	EnableState nvml.EnableState
} {
	var calls []struct {
		Device      nvml.Device
		EnableState nvml.EnableState
	}
	mock.lockDeviceSetAccountingMode.RLock()
	calls = mock.calls.DeviceSetAccountingMode
	mock.lockDeviceSetAccountingMode.RUnlock()
	return calls
}

// DeviceSetApplicationsClocks calls DeviceSetApplicationsClocksFunc.
func (mock *Interface) DeviceSetApplicationsClocks(device nvml.Device, v1 uint32, v2 uint32) nvml.Return {
	if mock.DeviceSetApplicationsClocksFunc == nil {
		panic("Interface.DeviceSetApplicationsClocksFunc: method is nil but Interface.DeviceSetApplicationsClocks was just called")
	}
	callInfo := struct {
		Device nvml.Device
		V1     uint32
		V2     uint32
	}{
		Device: device,
		V1:     v1,
		V2:     v2,
	}
	mock.lockDeviceSetApplicationsClocks.Lock()
	mock.calls.DeviceSetApplicationsClocks = append(mock.calls.DeviceSetApplicationsClocks, callInfo)
	mock.lockDeviceSetApplicationsClocks.Unlock()
	return mock.DeviceSetApplicationsClocksFunc(device, v1, v2)
}

// DeviceSetApplicationsClocksCalls gets all the calls that were made to DeviceSetApplicationsClocks.
// Check the length with:
//
//	len(mockedInterface.DeviceSetApplicationsClocksCalls())
func (mock *Interface) DeviceSetApplicationsClocksCalls() []struct {
	Device nvml.Device
	V1     uint32
	V2     uint32
} {
	var calls []struct {
		Device nvml.Device
		V1     uint32
		V2     uint32
	}
	mock.lockDeviceSetApplicationsClocks.RLock()
	calls = mock.calls.DeviceSetApplicationsClocks
	mock.lockDeviceSetApplicationsClocks.RUnlock()
	return calls
}

// DeviceSetAutoBoostedClocksEnabled calls DeviceSetAutoBoostedClocksEnabledFunc.
func (mock *Interface) DeviceSetAutoBoostedClocksEnabled(device nvml.Device, enableState nvml.EnableState) nvml.Return {
	if mock.DeviceSetAutoBoostedClocksEnabledFunc == nil {
		panic("Interface.DeviceSetAutoBoostedClocksEnabledFunc: method is nil but Interface.DeviceSetAutoBoostedClocksEnabled was just called")
	}
	callInfo := struct {
		Device      nvml.Device
		EnableState nvml.EnableState
	}{
		Device:      device,
		EnableState: enableState,
	}
	mock.lockDeviceSetAutoBoostedClocksEnabled.Lock()
	mock.calls.DeviceSetAutoBoostedClocksEnabled = append(mock.calls.DeviceSetAutoBoostedClocksEnabled, callInfo)
	mock.lockDeviceSetAutoBoostedClocksEnabled.Unlock()
	return mock.DeviceSetAutoBoostedClocksEnabledFunc(device, enableState)
}

// DeviceSetAutoBoostedClocksEnabledCalls gets all the calls that were made to DeviceSetAutoBoostedClocksEnabled.
// Check the length with:
//
//	len(mockedInterface.DeviceSetAutoBoostedClocksEnabledCalls())
func (mock *Interface) DeviceSetAutoBoostedClocksEnabledCalls() []struct {
	Device      nvml.Device
	EnableState nvml.EnableState
} {
	var calls []struct {
		Device      nvml.Device
		EnableState nvml.EnableState
	}
	mock.lockDeviceSetAutoBoostedClocksEnabled.RLock()
	calls = mock.calls.DeviceSetAutoBoostedClocksEnabled
	mock.lockDeviceSetAutoBoostedClocksEnabled.RUnlock()
	return calls
}

// DeviceSetClockOffsets calls DeviceSetClockOffsetsFunc.
func (mock *Interface) DeviceSetClockOffsets(device nvml.Device, clockOffset nvml.ClockOffset) nvml.Return {
	if mock.DeviceSetClockOffsetsFunc == nil {
		panic("Interface.DeviceSetClockOffsetsFunc: method is nil but Interface.DeviceSetClockOffsets was just called")
	}
	callInfo := struct {
		Device      nvml.Device
		ClockOffset nvml.ClockOffset
	}{
		Device:      device,
		ClockOffset: clockOffset,
	}
	mock.lockDeviceSetClockOffsets.Lock()
	mock.calls.DeviceSetClockOffsets = append(mock.calls.DeviceSetClockOffsets, callInfo)
	mock.lockDeviceSetClockOffsets.Unlock()
	return mock.DeviceSetClockOffsetsFunc(device, clockOffset)
}

// DeviceSetClockOffsetsCalls gets all the calls that were made to DeviceSetClockOffsets.
// Check the length with:
//
//	len(mockedInterface.DeviceSetClockOffsetsCalls())
func (mock *Interface) DeviceSetClockOffsetsCalls() []struct {
	Device      nvml.Device
	ClockOffset nvml.ClockOffset
} {
	var calls []struct {
		Device      nvml.Device
		ClockOffset nvml.ClockOffset
	}
	mock.lockDeviceSetClockOffsets.RLock()
	calls = mock.calls.DeviceSetClockOffsets
	mock.lockDeviceSetClockOffsets.RUnlock()
	return calls
}

// DeviceSetComputeMode calls DeviceSetComputeModeFunc.
func (mock *Interface) DeviceSetComputeMode(device nvml.Device, computeMode nvml.ComputeMode) nvml.Return {
	if mock.DeviceSetComputeModeFunc == nil {
		panic("Interface.DeviceSetComputeModeFunc: method is nil but Interface.DeviceSetComputeMode was just called")
	}
	callInfo := struct {
		Device      nvml.Device
		ComputeMode nvml.ComputeMode
	}{
		Device:      device,
		ComputeMode: computeMode,
	}
	mock.lockDeviceSetComputeMode.Lock()
	mock.calls.DeviceSetComputeMode = append(mock.calls.DeviceSetComputeMode, callInfo)
	mock.lockDeviceSetComputeMode.Unlock()
	return mock.DeviceSetComputeModeFunc(device, computeMode)
}

// DeviceSetComputeModeCalls gets all the calls that were made to DeviceSetComputeMode.
// Check the length with:
//
//	len(mockedInterface.DeviceSetComputeModeCalls())
func (mock *Interface) DeviceSetComputeModeCalls() []struct {
	Device      nvml.Device
	ComputeMode nvml.ComputeMode
} {
	var calls []struct {
		Device      nvml.Device
		ComputeMode nvml.ComputeMode
	}
	mock.lockDeviceSetComputeMode.RLock()
	calls = mock.calls.DeviceSetComputeMode
	mock.lockDeviceSetComputeMode.RUnlock()
	return calls
}

// DeviceSetConfComputeUnprotectedMemSize calls DeviceSetConfComputeUnprotectedMemSizeFunc.
func (mock *Interface) DeviceSetConfComputeUnprotectedMemSize(device nvml.Device, v uint64) nvml.Return {
	if mock.DeviceSetConfComputeUnprotectedMemSizeFunc == nil {
		panic("Interface.DeviceSetConfComputeUnprotectedMemSizeFunc: method is nil but Interface.DeviceSetConfComputeUnprotectedMemSize was just called")
	}
	callInfo := struct {
		Device nvml.Device
		V      uint64
	}{
		Device: device,
		V:      v,
	}
	mock.lockDeviceSetConfComputeUnprotectedMemSize.Lock()
	mock.calls.DeviceSetConfComputeUnprotectedMemSize = append(mock.calls.DeviceSetConfComputeUnprotectedMemSize, callInfo)
	mock.lockDeviceSetConfComputeUnprotectedMemSize.Unlock()
	return mock.DeviceSetConfComputeUnprotectedMemSizeFunc(device, v)
}

// DeviceSetConfComputeUnprotectedMemSizeCalls gets all the calls that were made to DeviceSetConfComputeUnprotectedMemSize.
// Check the length with:
//
//	len(mockedInterface.DeviceSetConfComputeUnprotectedMemSizeCalls())
func (mock *Interface) DeviceSetConfComputeUnprotectedMemSizeCalls() []struct {
	Device nvml.Device
	V      uint64
} {
	var calls []struct {
		Device nvml.Device
		V      uint64
	}
	mock.lockDeviceSetConfComputeUnprotectedMemSize.RLock()
	calls = mock.calls.DeviceSetConfComputeUnprotectedMemSize
	mock.lockDeviceSetConfComputeUnprotectedMemSize.RUnlock()
	return calls
}

// DeviceSetCpuAffinity calls DeviceSetCpuAffinityFunc.
func (mock *Interface) DeviceSetCpuAffinity(device nvml.Device) nvml.Return {
	if mock.DeviceSetCpuAffinityFunc == nil {
		panic("Interface.DeviceSetCpuAffinityFunc: method is nil but Interface.DeviceSetCpuAffinity was just called")
	}
	callInfo := struct {
		Device nvml.Device
	}{
		Device: device,
	}
	mock.lockDeviceSetCpuAffinity.Lock()
	mock.calls.DeviceSetCpuAffinity = append(mock.calls.DeviceSetCpuAffinity, callInfo)
	mock.lockDeviceSetCpuAffinity.Unlock()
	return mock.DeviceSetCpuAffinityFunc(device)
}

// DeviceSetCpuAffinityCalls gets all the calls that were made to DeviceSetCpuAffinity.
// Check the length with:
//
//	len(mockedInterface.DeviceSetCpuAffinityCalls())
func (mock *Interface) DeviceSetCpuAffinityCalls() []struct {
	Device nvml.Device
} {
	var calls []struct {
		Device nvml.Device
	}
	mock.lockDeviceSetCpuAffinity.RLock()
	calls = mock.calls.DeviceSetCpuAffinity
	mock.lockDeviceSetCpuAffinity.RUnlock()
	return calls
}

// DeviceSetDefaultAutoBoostedClocksEnabled calls DeviceSetDefaultAutoBoostedClocksEnabledFunc.
func (mock *Interface) DeviceSetDefaultAutoBoostedClocksEnabled(device nvml.Device, enableState nvml.EnableState, v uint32) nvml.Return {
	if mock.DeviceSetDefaultAutoBoostedClocksEnabledFunc == nil {
		panic("Interface.DeviceSetDefaultAutoBoostedClocksEnabledFunc: method is nil but Interface.DeviceSetDefaultAutoBoostedClocksEnabled was just called")
	}
	callInfo := struct {
		Device      nvml.Device
		EnableState nvml.EnableState
		V           uint32
	}{
		Device:      device,
		EnableState: enableState,
		V:           v,
	}
	mock.lockDeviceSetDefaultAutoBoostedClocksEnabled.Lock()
	mock.calls.DeviceSetDefaultAutoBoostedClocksEnabled = append(mock.calls.DeviceSetDefaultAutoBoostedClocksEnabled, callInfo)
	mock.lockDeviceSetDefaultAutoBoostedClocksEnabled.Unlock()
	return mock.DeviceSetDefaultAutoBoostedClocksEnabledFunc(device, enableState, v)
}

// DeviceSetDefaultAutoBoostedClocksEnabledCalls gets all the calls that were made to DeviceSetDefaultAutoBoostedClocksEnabled.
// Check the length with:
//
//	len(mockedInterface.DeviceSetDefaultAutoBoostedClocksEnabledCalls())
func (mock *Interface) DeviceSetDefaultAutoBoostedClocksEnabledCalls() []struct {
	Device      nvml.Device
	EnableState nvml.EnableState
	V           uint32
} {
	var calls []struct {
		Device      nvml.Device
		EnableState nvml.EnableState
		V           uint32
	}
	mock.lockDeviceSetDefaultAutoBoostedClocksEnabled.RLock()
	calls = mock.calls.DeviceSetDefaultAutoBoostedClocksEnabled
	mock.lockDeviceSetDefaultAutoBoostedClocksEnabled.RUnlock()
	return calls
}

// DeviceSetDefaultFanSpeed_v2 calls DeviceSetDefaultFanSpeed_v2Func.
func (mock *Interface) DeviceSetDefaultFanSpeed_v2(device nvml.Device, n int) nvml.Return {
	if mock.DeviceSetDefaultFanSpeed_v2Func == nil {
		panic("Interface.DeviceSetDefaultFanSpeed_v2Func: method is nil but Interface.DeviceSetDefaultFanSpeed_v2 was just called")
	}
	callInfo := struct {
		Device nvml.Device
		N      int
	}{
		Device: device,
		N:      n,
	}
	mock.lockDeviceSetDefaultFanSpeed_v2.Lock()
	mock.calls.DeviceSetDefaultFanSpeed_v2 = append(mock.calls.DeviceSetDefaultFanSpeed_v2, callInfo)
	mock.lockDeviceSetDefaultFanSpeed_v2.Unlock()
	return mock.DeviceSetDefaultFanSpeed_v2Func(device, n)
}

// DeviceSetDefaultFanSpeed_v2Calls gets all the calls that were made to DeviceSetDefaultFanSpeed_v2.
// Check the length with:
//
//	len(mockedInterface.DeviceSetDefaultFanSpeed_v2Calls())
func (mock *Interface) DeviceSetDefaultFanSpeed_v2Calls() []struct {
	Device nvml.Device
	N      int
} {
	var calls []struct {
		Device nvml.Device
		N      int
	}
	mock.lockDeviceSetDefaultFanSpeed_v2.RLock()
	calls = mock.calls.DeviceSetDefaultFanSpeed_v2
	mock.lockDeviceSetDefaultFanSpeed_v2.RUnlock()
	return calls
}

// DeviceSetDramEncryptionMode calls DeviceSetDramEncryptionModeFunc.
func (mock *Interface) DeviceSetDramEncryptionMode(device nvml.Device, dramEncryptionInfo *nvml.DramEncryptionInfo) nvml.Return {
	if mock.DeviceSetDramEncryptionModeFunc == nil {
		panic("Interface.DeviceSetDramEncryptionModeFunc: method is nil but Interface.DeviceSetDramEncryptionMode was just called")
	}
	callInfo := struct {
		Device             nvml.Device
		DramEncryptionInfo *nvml.DramEncryptionInfo
	}{
		Device:             device,
		DramEncryptionInfo: dramEncryptionInfo,
	}
	mock.lockDeviceSetDramEncryptionMode.Lock()
	mock.calls.DeviceSetDramEncryptionMode = append(mock.calls.DeviceSetDramEncryptionMode, callInfo)
	mock.lockDeviceSetDramEncryptionMode.Unlock()
	return mock.DeviceSetDramEncryptionModeFunc(device, dramEncryptionInfo)
}

// DeviceSetDramEncryptionModeCalls gets all the calls that were made to DeviceSetDramEncryptionMode.
// Check the length with:
//
//	len(mockedInterface.DeviceSetDramEncryptionModeCalls())
func (mock *Interface) DeviceSetDramEncryptionModeCalls() []struct {
	Device             nvml.Device
	DramEncryptionInfo *nvml.DramEncryptionInfo
} {
	var calls []struct {
		Device             nvml.Device
		DramEncryptionInfo *nvml.DramEncryptionInfo
	}
	mock.lockDeviceSetDramEncryptionMode.RLock()
	calls = mock.calls.DeviceSetDramEncryptionMode
	mock.lockDeviceSetDramEncryptionMode.RUnlock()
	return calls
}

// DeviceSetDriverModel calls DeviceSetDriverModelFunc.
func (mock *Interface) DeviceSetDriverModel(device nvml.Device, driverModel nvml.DriverModel, v uint32) nvml.Return {
	if mock.DeviceSetDriverModelFunc == nil {
		panic("Interface.DeviceSetDriverModelFunc: method is nil but Interface.DeviceSetDriverModel was just called")
	}
	callInfo := struct {
		Device      nvml.Device
		DriverModel nvml.DriverModel
		V           uint32
	}{
		Device:      device,
		DriverModel: driverModel,
		V:           v,
	}
	mock.lockDeviceSetDriverModel.Lock()
	mock.calls.DeviceSetDriverModel = append(mock.calls.DeviceSetDriverModel, callInfo)
	mock.lockDeviceSetDriverModel.Unlock()
	return mock.DeviceSetDriverModelFunc(device, driverModel, v)
}

// DeviceSetDriverModelCalls gets all the calls that were made to DeviceSetDriverModel.
// Check the length with:
//
//	len(mockedInterface.DeviceSetDriverModelCalls())
func (mock *Interface) DeviceSetDriverModelCalls() []struct {
	Device      nvml.Device
	DriverModel nvml.DriverModel
	V           uint32
} {
	var calls []struct {
		Device      nvml.Device
		DriverModel nvml.DriverModel
		V           uint32
	}
	mock.lockDeviceSetDriverModel.RLock()
	calls = mock.calls.DeviceSetDriverModel
	mock.lockDeviceSetDriverModel.RUnlock()
	return calls
}

// DeviceSetEccMode calls DeviceSetEccModeFunc.
func (mock *Interface) DeviceSetEccMode(device nvml.Device, enableState nvml.EnableState) nvml.Return {
	if mock.DeviceSetEccModeFunc == nil {
		panic("Interface.DeviceSetEccModeFunc: method is nil but Interface.DeviceSetEccMode was just called")
	}
	callInfo := struct {
		Device      nvml.Device
		EnableState nvml.EnableState
	}{
		Device:      device,
		EnableState: enableState,
	}
	mock.lockDeviceSetEccMode.Lock()
	mock.calls.DeviceSetEccMode = append(mock.calls.DeviceSetEccMode, callInfo)
	mock.lockDeviceSetEccMode.Unlock()
	return mock.DeviceSetEccModeFunc(device, enableState)
}

// DeviceSetEccModeCalls gets all the calls that were made to DeviceSetEccMode.
// Check the length with:
//
//	len(mockedInterface.DeviceSetEccModeCalls())
func (mock *Interface) DeviceSetEccModeCalls() []struct {
	Device      nvml.Device
	EnableState nvml.EnableState
} {
	var calls []struct {
		Device      nvml.Device
		EnableState nvml.EnableState
	}
	mock.lockDeviceSetEccMode.RLock()
	calls = mock.calls.DeviceSetEccMode
	mock.lockDeviceSetEccMode.RUnlock()
	return calls
}

// DeviceSetFanControlPolicy calls DeviceSetFanControlPolicyFunc.
func (mock *Interface) DeviceSetFanControlPolicy(device nvml.Device, n int, fanControlPolicy nvml.FanControlPolicy) nvml.Return {
	if mock.DeviceSetFanControlPolicyFunc == nil {
		panic("Interface.DeviceSetFanControlPolicyFunc: method is nil but Interface.DeviceSetFanControlPolicy was just called")
	}
	callInfo := struct {
		Device           nvml.Device
		N                int
		FanControlPolicy nvml.FanControlPolicy
	}{
		Device:           device,
		N:                n,
		FanControlPolicy: fanControlPolicy,
	}
	mock.lockDeviceSetFanControlPolicy.Lock()
	mock.calls.DeviceSetFanControlPolicy = append(mock.calls.DeviceSetFanControlPolicy, callInfo)
	mock.lockDeviceSetFanControlPolicy.Unlock()
	return mock.DeviceSetFanControlPolicyFunc(device, n, fanControlPolicy)
}

// DeviceSetFanControlPolicyCalls gets all the calls that were made to DeviceSetFanControlPolicy.
// Check the length with:
//
//	len(mockedInterface.DeviceSetFanControlPolicyCalls())
func (mock *Interface) DeviceSetFanControlPolicyCalls() []struct {
	Device           nvml.Device
	N                int
	FanControlPolicy nvml.FanControlPolicy
} {
	var calls []struct {
		Device           nvml.Device
		N                int
		FanControlPolicy nvml.FanControlPolicy
	}
	mock.lockDeviceSetFanControlPolicy.RLock()
	calls = mock.calls.DeviceSetFanControlPolicy
	mock.lockDeviceSetFanControlPolicy.RUnlock()
	return calls
}

// DeviceSetFanSpeed_v2 calls DeviceSetFanSpeed_v2Func.
func (mock *Interface) DeviceSetFanSpeed_v2(device nvml.Device, n1 int, n2 int) nvml.Return {
	if mock.DeviceSetFanSpeed_v2Func == nil {
		panic("Interface.DeviceSetFanSpeed_v2Func: method is nil but Interface.DeviceSetFanSpeed_v2 was just called")
	}
	callInfo := struct {
		Device nvml.Device
		N1     int
		N2     int
	}{
		Device: device,
		N1:     n1,
		N2:     n2,
	}
	mock.lockDeviceSetFanSpeed_v2.Lock()
	mock.calls.DeviceSetFanSpeed_v2 = append(mock.calls.DeviceSetFanSpeed_v2, callInfo)
	mock.lockDeviceSetFanSpeed_v2.Unlock()
	return mock.DeviceSetFanSpeed_v2Func(device, n1, n2)
}

// DeviceSetFanSpeed_v2Calls gets all the calls that were made to DeviceSetFanSpeed_v2.
// Check the length with:
//
//	len(mockedInterface.DeviceSetFanSpeed_v2Calls())
func (mock *Interface) DeviceSetFanSpeed_v2Calls() []struct {
	Device nvml.Device
	N1     int
	N2     int
} {
	var calls []struct {
		Device nvml.Device
		N1     int
		N2     int
	}
	mock.lockDeviceSetFanSpeed_v2.RLock()
	calls = mock.calls.DeviceSetFanSpeed_v2
	mock.lockDeviceSetFanSpeed_v2.RUnlock()
	return calls
}

// DeviceSetGpcClkVfOffset calls DeviceSetGpcClkVfOffsetFunc.
func (mock *Interface) DeviceSetGpcClkVfOffset(device nvml.Device, n int) nvml.Return {
	if mock.DeviceSetGpcClkVfOffsetFunc == nil {
		panic("Interface.DeviceSetGpcClkVfOffsetFunc: method is nil but Interface.DeviceSetGpcClkVfOffset was just called")
	}
	callInfo := struct {
		Device nvml.Device
		N      int
	}{
		Device: device,
		N:      n,
	}
	mock.lockDeviceSetGpcClkVfOffset.Lock()
	mock.calls.DeviceSetGpcClkVfOffset = append(mock.calls.DeviceSetGpcClkVfOffset, callInfo)
	mock.lockDeviceSetGpcClkVfOffset.Unlock()
	return mock.DeviceSetGpcClkVfOffsetFunc(device, n)
}

// DeviceSetGpcClkVfOffsetCalls gets all the calls that were made to DeviceSetGpcClkVfOffset.
// Check the length with:
//
//	len(mockedInterface.DeviceSetGpcClkVfOffsetCalls())
func (mock *Interface) DeviceSetGpcClkVfOffsetCalls() []struct {
	Device nvml.Device
	N      int
} {
	var calls []struct {
		Device nvml.Device
		N      int
	}
	mock.lockDeviceSetGpcClkVfOffset.RLock()
	calls = mock.calls.DeviceSetGpcClkVfOffset
	mock.lockDeviceSetGpcClkVfOffset.RUnlock()
	return calls
}

// DeviceSetGpuLockedClocks calls DeviceSetGpuLockedClocksFunc.
func (mock *Interface) DeviceSetGpuLockedClocks(device nvml.Device, v1 uint32, v2 uint32) nvml.Return {
	if mock.DeviceSetGpuLockedClocksFunc == nil {
		panic("Interface.DeviceSetGpuLockedClocksFunc: method is nil but Interface.DeviceSetGpuLockedClocks was just called")
	}
	callInfo := struct {
		Device nvml.Device
		V1     uint32
		V2     uint32
	}{
		Device: device,
		V1:     v1,
		V2:     v2,
	}
	mock.lockDeviceSetGpuLockedClocks.Lock()
	mock.calls.DeviceSetGpuLockedClocks = append(mock.calls.DeviceSetGpuLockedClocks, callInfo)
	mock.lockDeviceSetGpuLockedClocks.Unlock()
	return mock.DeviceSetGpuLockedClocksFunc(device, v1, v2)
}

// DeviceSetGpuLockedClocksCalls gets all the calls that were made to DeviceSetGpuLockedClocks.
// Check the length with:
//
//	len(mockedInterface.DeviceSetGpuLockedClocksCalls())
func (mock *Interface) DeviceSetGpuLockedClocksCalls() []struct {
	Device nvml.Device
	V1     uint32
	V2     uint32
} {
	var calls []struct {
		Device nvml.Device
		V1     uint32
		V2     uint32
	}
	mock.lockDeviceSetGpuLockedClocks.RLock()
	calls = mock.calls.DeviceSetGpuLockedClocks
	mock.lockDeviceSetGpuLockedClocks.RUnlock()
	return calls
}

// DeviceSetGpuOperationMode calls DeviceSetGpuOperationModeFunc.
func (mock *Interface) DeviceSetGpuOperationMode(device nvml.Device, gpuOperationMode nvml.GpuOperationMode) nvml.Return {
	if mock.DeviceSetGpuOperationModeFunc == nil {
		panic("Interface.DeviceSetGpuOperationModeFunc: method is nil but Interface.DeviceSetGpuOperationMode was just called")
	}
	callInfo := struct {
		Device           nvml.Device
		GpuOperationMode nvml.GpuOperationMode
	}{
		Device:           device,
		GpuOperationMode: gpuOperationMode,
	}
	mock.lockDeviceSetGpuOperationMode.Lock()
	mock.calls.DeviceSetGpuOperationMode = append(mock.calls.DeviceSetGpuOperationMode, callInfo)
	mock.lockDeviceSetGpuOperationMode.Unlock()
	return mock.DeviceSetGpuOperationModeFunc(device, gpuOperationMode)
}

// DeviceSetGpuOperationModeCalls gets all the calls that were made to DeviceSetGpuOperationMode.
// Check the length with:
//
//	len(mockedInterface.DeviceSetGpuOperationModeCalls())
func (mock *Interface) DeviceSetGpuOperationModeCalls() []struct {
	Device           nvml.Device
	GpuOperationMode nvml.GpuOperationMode
} {
	var calls []struct {
		Device           nvml.Device
		GpuOperationMode nvml.GpuOperationMode
	}
	mock.lockDeviceSetGpuOperationMode.RLock()
	calls = mock.calls.DeviceSetGpuOperationMode
	mock.lockDeviceSetGpuOperationMode.RUnlock()
	return calls
}

// DeviceSetMemClkVfOffset calls DeviceSetMemClkVfOffsetFunc.
func (mock *Interface) DeviceSetMemClkVfOffset(device nvml.Device, n int) nvml.Return {
	if mock.DeviceSetMemClkVfOffsetFunc == nil {
		panic("Interface.DeviceSetMemClkVfOffsetFunc: method is nil but Interface.DeviceSetMemClkVfOffset was just called")
	}
	callInfo := struct {
		Device nvml.Device
		N      int
	}{
		Device: device,
		N:      n,
	}
	mock.lockDeviceSetMemClkVfOffset.Lock()
	mock.calls.DeviceSetMemClkVfOffset = append(mock.calls.DeviceSetMemClkVfOffset, callInfo)
	mock.lockDeviceSetMemClkVfOffset.Unlock()
	return mock.DeviceSetMemClkVfOffsetFunc(device, n)
}

// DeviceSetMemClkVfOffsetCalls gets all the calls that were made to DeviceSetMemClkVfOffset.
// Check the length with:
//
//	len(mockedInterface.DeviceSetMemClkVfOffsetCalls())
func (mock *Interface) DeviceSetMemClkVfOffsetCalls() []struct {
	Device nvml.Device
	N      int
} {
	var calls []struct {
		Device nvml.Device
		N      int
	}
	mock.lockDeviceSetMemClkVfOffset.RLock()
	calls = mock.calls.DeviceSetMemClkVfOffset
	mock.lockDeviceSetMemClkVfOffset.RUnlock()
	return calls
}

// DeviceSetMemoryLockedClocks calls DeviceSetMemoryLockedClocksFunc.
func (mock *Interface) DeviceSetMemoryLockedClocks(device nvml.Device, v1 uint32, v2 uint32) nvml.Return {
	if mock.DeviceSetMemoryLockedClocksFunc == nil {
		panic("Interface.DeviceSetMemoryLockedClocksFunc: method is nil but Interface.DeviceSetMemoryLockedClocks was just called")
	}
	callInfo := struct {
		Device nvml.Device
		V1     uint32
		V2     uint32
	}{
		Device: device,
		V1:     v1,
		V2:     v2,
	}
	mock.lockDeviceSetMemoryLockedClocks.Lock()
	mock.calls.DeviceSetMemoryLockedClocks = append(mock.calls.DeviceSetMemoryLockedClocks, callInfo)
	mock.lockDeviceSetMemoryLockedClocks.Unlock()
	return mock.DeviceSetMemoryLockedClocksFunc(device, v1, v2)
}

// DeviceSetMemoryLockedClocksCalls gets all the calls that were made to DeviceSetMemoryLockedClocks.
// Check the length with:
//
//	len(mockedInterface.DeviceSetMemoryLockedClocksCalls())
func (mock *Interface) DeviceSetMemoryLockedClocksCalls() []struct {
	Device nvml.Device
	V1     uint32
	V2     uint32
} {
	var calls []struct {
		Device nvml.Device
		V1     uint32
		V2     uint32
	}
	mock.lockDeviceSetMemoryLockedClocks.RLock()
	calls = mock.calls.DeviceSetMemoryLockedClocks
	mock.lockDeviceSetMemoryLockedClocks.RUnlock()
	return calls
}

// DeviceSetMigMode calls DeviceSetMigModeFunc.
func (mock *Interface) DeviceSetMigMode(device nvml.Device, n int) (nvml.Return, nvml.Return) {
	if mock.DeviceSetMigModeFunc == nil {
		panic("Interface.DeviceSetMigModeFunc: method is nil but Interface.DeviceSetMigMode was just called")
	}
	callInfo := struct {
		Device nvml.Device
		N      int
	}{
		Device: device,
		N:      n,
	}
	mock.lockDeviceSetMigMode.Lock()
	mock.calls.DeviceSetMigMode = append(mock.calls.DeviceSetMigMode, callInfo)
	mock.lockDeviceSetMigMode.Unlock()
	return mock.DeviceSetMigModeFunc(device, n)
}

// DeviceSetMigModeCalls gets all the calls that were made to DeviceSetMigMode.
// Check the length with:
//
//	len(mockedInterface.DeviceSetMigModeCalls())
func (mock *Interface) DeviceSetMigModeCalls() []struct {
	Device nvml.Device
	N      int
} {
	var calls []struct {
		Device nvml.Device
		N      int
	}
	mock.lockDeviceSetMigMode.RLock()
	calls = mock.calls.DeviceSetMigMode
	mock.lockDeviceSetMigMode.RUnlock()
	return calls
}

// DeviceSetNvLinkDeviceLowPowerThreshold calls DeviceSetNvLinkDeviceLowPowerThresholdFunc.
func (mock *Interface) DeviceSetNvLinkDeviceLowPowerThreshold(device nvml.Device, nvLinkPowerThres *nvml.NvLinkPowerThres) nvml.Return {
	if mock.DeviceSetNvLinkDeviceLowPowerThresholdFunc == nil {
		panic("Interface.DeviceSetNvLinkDeviceLowPowerThresholdFunc: method is nil but Interface.DeviceSetNvLinkDeviceLowPowerThreshold was just called")
	}
	callInfo := struct {
		Device           nvml.Device
		NvLinkPowerThres *nvml.NvLinkPowerThres
	}{
		Device:           device,
		NvLinkPowerThres: nvLinkPowerThres,
	}
	mock.lockDeviceSetNvLinkDeviceLowPowerThreshold.Lock()
	mock.calls.DeviceSetNvLinkDeviceLowPowerThreshold = append(mock.calls.DeviceSetNvLinkDeviceLowPowerThreshold, callInfo)
	mock.lockDeviceSetNvLinkDeviceLowPowerThreshold.Unlock()
	return mock.DeviceSetNvLinkDeviceLowPowerThresholdFunc(device, nvLinkPowerThres)
}

// DeviceSetNvLinkDeviceLowPowerThresholdCalls gets all the calls that were made to DeviceSetNvLinkDeviceLowPowerThreshold.
// Check the length with:
//
//	len(mockedInterface.DeviceSetNvLinkDeviceLowPowerThresholdCalls())
func (mock *Interface) DeviceSetNvLinkDeviceLowPowerThresholdCalls() []struct {
	Device           nvml.Device
	NvLinkPowerThres *nvml.NvLinkPowerThres
} {
	var calls []struct {
		Device           nvml.Device
		NvLinkPowerThres *nvml.NvLinkPowerThres
	}
	mock.lockDeviceSetNvLinkDeviceLowPowerThreshold.RLock()
	calls = mock.calls.DeviceSetNvLinkDeviceLowPowerThreshold
	mock.lockDeviceSetNvLinkDeviceLowPowerThreshold.RUnlock()
	return calls
}

// DeviceSetNvLinkUtilizationControl calls DeviceSetNvLinkUtilizationControlFunc.
func (mock *Interface) DeviceSetNvLinkUtilizationControl(device nvml.Device, n1 int, n2 int, nvLinkUtilizationControl *nvml.NvLinkUtilizationControl, b bool) nvml.Return {
	if mock.DeviceSetNvLinkUtilizationControlFunc == nil {
		panic("Interface.DeviceSetNvLinkUtilizationControlFunc: method is nil but Interface.DeviceSetNvLinkUtilizationControl was just called")
	}
	callInfo := struct {
		Device                   nvml.Device
		N1                       int
		N2                       int
		NvLinkUtilizationControl *nvml.NvLinkUtilizationControl
		B                        bool
	}{
		Device:                   device,
		N1:                       n1,
		N2:                       n2,
		NvLinkUtilizationControl: nvLinkUtilizationControl,
		B:                        b,
	}
	mock.lockDeviceSetNvLinkUtilizationControl.Lock()
	mock.calls.DeviceSetNvLinkUtilizationControl = append(mock.calls.DeviceSetNvLinkUtilizationControl, callInfo)
	mock.lockDeviceSetNvLinkUtilizationControl.Unlock()
	return mock.DeviceSetNvLinkUtilizationControlFunc(device, n1, n2, nvLinkUtilizationControl, b)
}

// DeviceSetNvLinkUtilizationControlCalls gets all the calls that were made to DeviceSetNvLinkUtilizationControl.
// Check the length with:
//
//	len(mockedInterface.DeviceSetNvLinkUtilizationControlCalls())
func (mock *Interface) DeviceSetNvLinkUtilizationControlCalls() []struct {
	Device                   nvml.Device
	N1                       int
	N2                       int
	NvLinkUtilizationControl *nvml.NvLinkUtilizationControl
	B                        bool
} {
	var calls []struct {
		Device                   nvml.Device
		N1                       int
		N2                       int
		NvLinkUtilizationControl *nvml.NvLinkUtilizationControl
		B                        bool
	}
	mock.lockDeviceSetNvLinkUtilizationControl.RLock()
	calls = mock.calls.DeviceSetNvLinkUtilizationControl
	mock.lockDeviceSetNvLinkUtilizationControl.RUnlock()
	return calls
}

// DeviceSetNvlinkBwMode calls DeviceSetNvlinkBwModeFunc.
func (mock *Interface) DeviceSetNvlinkBwMode(device nvml.Device, nvlinkSetBwMode *nvml.NvlinkSetBwMode) nvml.Return {
	if mock.DeviceSetNvlinkBwModeFunc == nil {
		panic("Interface.DeviceSetNvlinkBwModeFunc: method is nil but Interface.DeviceSetNvlinkBwMode was just called")
	}
	callInfo := struct {
		Device          nvml.Device
		NvlinkSetBwMode *nvml.NvlinkSetBwMode
	}{
		Device:          device,
		NvlinkSetBwMode: nvlinkSetBwMode,
	}
	mock.lockDeviceSetNvlinkBwMode.Lock()
	mock.calls.DeviceSetNvlinkBwMode = append(mock.calls.DeviceSetNvlinkBwMode, callInfo)
	mock.lockDeviceSetNvlinkBwMode.Unlock()
	return mock.DeviceSetNvlinkBwModeFunc(device, nvlinkSetBwMode)
}

// DeviceSetNvlinkBwModeCalls gets all the calls that were made to DeviceSetNvlinkBwMode.
// Check the length with:
//
//	len(mockedInterface.DeviceSetNvlinkBwModeCalls())
func (mock *Interface) DeviceSetNvlinkBwModeCalls() []struct {
	Device          nvml.Device
	NvlinkSetBwMode *nvml.NvlinkSetBwMode
} {
	var calls []struct {
		Device          nvml.Device
		NvlinkSetBwMode *nvml.NvlinkSetBwMode
	}
	mock.lockDeviceSetNvlinkBwMode.RLock()
	calls = mock.calls.DeviceSetNvlinkBwMode
	mock.lockDeviceSetNvlinkBwMode.RUnlock()
	return calls
}

// DeviceSetPersistenceMode calls DeviceSetPersistenceModeFunc.
func (mock *Interface) DeviceSetPersistenceMode(device nvml.Device, enableState nvml.EnableState) nvml.Return {
	if mock.DeviceSetPersistenceModeFunc == nil {
		panic("Interface.DeviceSetPersistenceModeFunc: method is nil but Interface.DeviceSetPersistenceMode was just called")
	}
	callInfo := struct {
		Device      nvml.Device
		EnableState nvml.EnableState
	}{
		Device:      device,
		EnableState: enableState,
	}
	mock.lockDeviceSetPersistenceMode.Lock()
	mock.calls.DeviceSetPersistenceMode = append(mock.calls.DeviceSetPersistenceMode, callInfo)
	mock.lockDeviceSetPersistenceMode.Unlock()
	return mock.DeviceSetPersistenceModeFunc(device, enableState)
}

// DeviceSetPersistenceModeCalls gets all the calls that were made to DeviceSetPersistenceMode.
// Check the length with:
//
//	len(mockedInterface.DeviceSetPersistenceModeCalls())
func (mock *Interface) DeviceSetPersistenceModeCalls() []struct {
	Device      nvml.Device
	EnableState nvml.EnableState
} {
	var calls []struct {
		Device      nvml.Device
		EnableState nvml.EnableState
	}
	mock.lockDeviceSetPersistenceMode.RLock()
	calls = mock.calls.DeviceSetPersistenceMode
	mock.lockDeviceSetPersistenceMode.RUnlock()
	return calls
}

// DeviceSetPowerManagementLimit calls DeviceSetPowerManagementLimitFunc.
func (mock *Interface) DeviceSetPowerManagementLimit(device nvml.Device, v uint32) nvml.Return {
	if mock.DeviceSetPowerManagementLimitFunc == nil {
		panic("Interface.DeviceSetPowerManagementLimitFunc: method is nil but Interface.DeviceSetPowerManagementLimit was just called")
	}
	callInfo := struct {
		Device nvml.Device
		V      uint32
	}{
		Device: device,
		V:      v,
	}
	mock.lockDeviceSetPowerManagementLimit.Lock()
	mock.calls.DeviceSetPowerManagementLimit = append(mock.calls.DeviceSetPowerManagementLimit, callInfo)
	mock.lockDeviceSetPowerManagementLimit.Unlock()
	return mock.DeviceSetPowerManagementLimitFunc(device, v)
}

// DeviceSetPowerManagementLimitCalls gets all the calls that were made to DeviceSetPowerManagementLimit.
// Check the length with:
//
//	len(mockedInterface.DeviceSetPowerManagementLimitCalls())
func (mock *Interface) DeviceSetPowerManagementLimitCalls() []struct {
	Device nvml.Device
	V      uint32
} {
	var calls []struct {
		Device nvml.Device
		V      uint32
	}
	mock.lockDeviceSetPowerManagementLimit.RLock()
	calls = mock.calls.DeviceSetPowerManagementLimit
	mock.lockDeviceSetPowerManagementLimit.RUnlock()
	return calls
}

// DeviceSetPowerManagementLimit_v2 calls DeviceSetPowerManagementLimit_v2Func.
func (mock *Interface) DeviceSetPowerManagementLimit_v2(device nvml.Device, powerValue_v2 *nvml.PowerValue_v2) nvml.Return {
	if mock.DeviceSetPowerManagementLimit_v2Func == nil {
		panic("Interface.DeviceSetPowerManagementLimit_v2Func: method is nil but Interface.DeviceSetPowerManagementLimit_v2 was just called")
	}
	callInfo := struct {
		Device        nvml.Device
		PowerValue_v2 *nvml.PowerValue_v2
	}{
		Device:        device,
		PowerValue_v2: powerValue_v2,
	}
	mock.lockDeviceSetPowerManagementLimit_v2.Lock()
	mock.calls.DeviceSetPowerManagementLimit_v2 = append(mock.calls.DeviceSetPowerManagementLimit_v2, callInfo)
	mock.lockDeviceSetPowerManagementLimit_v2.Unlock()
	return mock.DeviceSetPowerManagementLimit_v2Func(device, powerValue_v2)
}

// DeviceSetPowerManagementLimit_v2Calls gets all the calls that were made to DeviceSetPowerManagementLimit_v2.
// Check the length with:
//
//	len(mockedInterface.DeviceSetPowerManagementLimit_v2Calls())
func (mock *Interface) DeviceSetPowerManagementLimit_v2Calls() []struct {
	Device        nvml.Device
	PowerValue_v2 *nvml.PowerValue_v2
} {
	var calls []struct {
		Device        nvml.Device
		PowerValue_v2 *nvml.PowerValue_v2
	}
	mock.lockDeviceSetPowerManagementLimit_v2.RLock()
	calls = mock.calls.DeviceSetPowerManagementLimit_v2
	mock.lockDeviceSetPowerManagementLimit_v2.RUnlock()
	return calls
}

// DeviceSetTemperatureThreshold calls DeviceSetTemperatureThresholdFunc.
func (mock *Interface) DeviceSetTemperatureThreshold(device nvml.Device, temperatureThresholds nvml.TemperatureThresholds, n int) nvml.Return {
	if mock.DeviceSetTemperatureThresholdFunc == nil {
		panic("Interface.DeviceSetTemperatureThresholdFunc: method is nil but Interface.DeviceSetTemperatureThreshold was just called")
	}
	callInfo := struct {
		Device                nvml.Device
		TemperatureThresholds nvml.TemperatureThresholds
		N                     int
	}{
		Device:                device,
		TemperatureThresholds: temperatureThresholds,
		N:                     n,
	}
	mock.lockDeviceSetTemperatureThreshold.Lock()
	mock.calls.DeviceSetTemperatureThreshold = append(mock.calls.DeviceSetTemperatureThreshold, callInfo)
	mock.lockDeviceSetTemperatureThreshold.Unlock()
	return mock.DeviceSetTemperatureThresholdFunc(device, temperatureThresholds, n)
}

// DeviceSetTemperatureThresholdCalls gets all the calls that were made to DeviceSetTemperatureThreshold.
// Check the length with:
//
//	len(mockedInterface.DeviceSetTemperatureThresholdCalls())
func (mock *Interface) DeviceSetTemperatureThresholdCalls() []struct {
	Device                nvml.Device
	TemperatureThresholds nvml.TemperatureThresholds
	N                     int
} {
	var calls []struct {
		Device                nvml.Device
		TemperatureThresholds nvml.TemperatureThresholds
		N                     int
	}
	mock.lockDeviceSetTemperatureThreshold.RLock()
	calls = mock.calls.DeviceSetTemperatureThreshold
	mock.lockDeviceSetTemperatureThreshold.RUnlock()
	return calls
}

// DeviceSetVgpuCapabilities calls DeviceSetVgpuCapabilitiesFunc.
func (mock *Interface) DeviceSetVgpuCapabilities(device nvml.Device, deviceVgpuCapability nvml.DeviceVgpuCapability, enableState nvml.EnableState) nvml.Return {
	if mock.DeviceSetVgpuCapabilitiesFunc == nil {
		panic("Interface.DeviceSetVgpuCapabilitiesFunc: method is nil but Interface.DeviceSetVgpuCapabilities was just called")
	}
	callInfo := struct {
		Device               nvml.Device
		DeviceVgpuCapability nvml.DeviceVgpuCapability
		EnableState          nvml.EnableState
	}{
		Device:               device,
		DeviceVgpuCapability: deviceVgpuCapability,
		EnableState:          enableState,
	}
	mock.lockDeviceSetVgpuCapabilities.Lock()
	mock.calls.DeviceSetVgpuCapabilities = append(mock.calls.DeviceSetVgpuCapabilities, callInfo)
	mock.lockDeviceSetVgpuCapabilities.Unlock()
	return mock.DeviceSetVgpuCapabilitiesFunc(device, deviceVgpuCapability, enableState)
}

// DeviceSetVgpuCapabilitiesCalls gets all the calls that were made to DeviceSetVgpuCapabilities.
// Check the length with:
//
//	len(mockedInterface.DeviceSetVgpuCapabilitiesCalls())
func (mock *Interface) DeviceSetVgpuCapabilitiesCalls() []struct {
	Device               nvml.Device
	DeviceVgpuCapability nvml.DeviceVgpuCapability
	EnableState          nvml.EnableState
} {
	var calls []struct {
		Device               nvml.Device
		DeviceVgpuCapability nvml.DeviceVgpuCapability
		EnableState          nvml.EnableState
	}
	mock.lockDeviceSetVgpuCapabilities.RLock()
	calls = mock.calls.DeviceSetVgpuCapabilities
	mock.lockDeviceSetVgpuCapabilities.RUnlock()
	return calls
}

// DeviceSetVgpuHeterogeneousMode calls DeviceSetVgpuHeterogeneousModeFunc.
func (mock *Interface) DeviceSetVgpuHeterogeneousMode(device nvml.Device, vgpuHeterogeneousMode nvml.VgpuHeterogeneousMode) nvml.Return {
	if mock.DeviceSetVgpuHeterogeneousModeFunc == nil {
		panic("Interface.DeviceSetVgpuHeterogeneousModeFunc: method is nil but Interface.DeviceSetVgpuHeterogeneousMode was just called")
	}
	callInfo := struct {
		Device                nvml.Device
		VgpuHeterogeneousMode nvml.VgpuHeterogeneousMode
	}{
		Device:                device,
		VgpuHeterogeneousMode: vgpuHeterogeneousMode,
	}
	mock.lockDeviceSetVgpuHeterogeneousMode.Lock()
	mock.calls.DeviceSetVgpuHeterogeneousMode = append(mock.calls.DeviceSetVgpuHeterogeneousMode, callInfo)
	mock.lockDeviceSetVgpuHeterogeneousMode.Unlock()
	return mock.DeviceSetVgpuHeterogeneousModeFunc(device, vgpuHeterogeneousMode)
}

// DeviceSetVgpuHeterogeneousModeCalls gets all the calls that were made to DeviceSetVgpuHeterogeneousMode.
// Check the length with:
//
//	len(mockedInterface.DeviceSetVgpuHeterogeneousModeCalls())
func (mock *Interface) DeviceSetVgpuHeterogeneousModeCalls() []struct {
	Device                nvml.Device
	VgpuHeterogeneousMode nvml.VgpuHeterogeneousMode
} {
	var calls []struct {
		Device                nvml.Device
		VgpuHeterogeneousMode nvml.VgpuHeterogeneousMode
	}
	mock.lockDeviceSetVgpuHeterogeneousMode.RLock()
	calls = mock.calls.DeviceSetVgpuHeterogeneousMode
	mock.lockDeviceSetVgpuHeterogeneousMode.RUnlock()
	return calls
}

// DeviceSetVgpuSchedulerState calls DeviceSetVgpuSchedulerStateFunc.
func (mock *Interface) DeviceSetVgpuSchedulerState(device nvml.Device, vgpuSchedulerSetState *nvml.VgpuSchedulerSetState) nvml.Return {
	if mock.DeviceSetVgpuSchedulerStateFunc == nil {
		panic("Interface.DeviceSetVgpuSchedulerStateFunc: method is nil but Interface.DeviceSetVgpuSchedulerState was just called")
	}
	callInfo := struct {
		Device                nvml.Device
		VgpuSchedulerSetState *nvml.VgpuSchedulerSetState
	}{
		Device:                device,
		VgpuSchedulerSetState: vgpuSchedulerSetState,
	}
	mock.lockDeviceSetVgpuSchedulerState.Lock()
	mock.calls.DeviceSetVgpuSchedulerState = append(mock.calls.DeviceSetVgpuSchedulerState, callInfo)
	mock.lockDeviceSetVgpuSchedulerState.Unlock()
	return mock.DeviceSetVgpuSchedulerStateFunc(device, vgpuSchedulerSetState)
}

// DeviceSetVgpuSchedulerStateCalls gets all the calls that were made to DeviceSetVgpuSchedulerState.
// Check the length with:
//
//	len(mockedInterface.DeviceSetVgpuSchedulerStateCalls())
func (mock *Interface) DeviceSetVgpuSchedulerStateCalls() []struct {
	Device                nvml.Device
	VgpuSchedulerSetState *nvml.VgpuSchedulerSetState
} {
	var calls []struct {
		Device                nvml.Device
		VgpuSchedulerSetState *nvml.VgpuSchedulerSetState
	}
	mock.lockDeviceSetVgpuSchedulerState.RLock()
	calls = mock.calls.DeviceSetVgpuSchedulerState
	mock.lockDeviceSetVgpuSchedulerState.RUnlock()
	return calls
}

// DeviceSetVirtualizationMode calls DeviceSetVirtualizationModeFunc.
func (mock *Interface) DeviceSetVirtualizationMode(device nvml.Device, gpuVirtualizationMode nvml.GpuVirtualizationMode) nvml.Return {
	if mock.DeviceSetVirtualizationModeFunc == nil {
		panic("Interface.DeviceSetVirtualizationModeFunc: method is nil but Interface.DeviceSetVirtualizationMode was just called")
	}
	callInfo := struct {
		Device                nvml.Device
		GpuVirtualizationMode nvml.GpuVirtualizationMode
	}{
		Device:                device,
		GpuVirtualizationMode: gpuVirtualizationMode,
	}
	mock.lockDeviceSetVirtualizationMode.Lock()
	mock.calls.DeviceSetVirtualizationMode = append(mock.calls.DeviceSetVirtualizationMode, callInfo)
	mock.lockDeviceSetVirtualizationMode.Unlock()
	return mock.DeviceSetVirtualizationModeFunc(device, gpuVirtualizationMode)
}

// DeviceSetVirtualizationModeCalls gets all the calls that were made to DeviceSetVirtualizationMode.
// Check the length with:
//
//	len(mockedInterface.DeviceSetVirtualizationModeCalls())
func (mock *Interface) DeviceSetVirtualizationModeCalls() []struct {
	Device                nvml.Device
	GpuVirtualizationMode nvml.GpuVirtualizationMode
} {
	var calls []struct {
		Device                nvml.Device
		GpuVirtualizationMode nvml.GpuVirtualizationMode
	}
	mock.lockDeviceSetVirtualizationMode.RLock()
	calls = mock.calls.DeviceSetVirtualizationMode
	mock.lockDeviceSetVirtualizationMode.RUnlock()
	return calls
}

// DeviceValidateInforom calls DeviceValidateInforomFunc.
func (mock *Interface) DeviceValidateInforom(device nvml.Device) nvml.Return {
	if mock.DeviceValidateInforomFunc == nil {
		panic("Interface.DeviceValidateInforomFunc: method is nil but Interface.DeviceValidateInforom was just called")
	}
	callInfo := struct {
		Device nvml.Device
	}{
		Device: device,
	}
	mock.lockDeviceValidateInforom.Lock()
	mock.calls.DeviceValidateInforom = append(mock.calls.DeviceValidateInforom, callInfo)
	mock.lockDeviceValidateInforom.Unlock()
	return mock.DeviceValidateInforomFunc(device)
}

// DeviceValidateInforomCalls gets all the calls that were made to DeviceValidateInforom.
// Check the length with:
//
//	len(mockedInterface.DeviceValidateInforomCalls())
func (mock *Interface) DeviceValidateInforomCalls() []struct {
	Device nvml.Device
} {
	var calls []struct {
		Device nvml.Device
	}
	mock.lockDeviceValidateInforom.RLock()
	calls = mock.calls.DeviceValidateInforom
	mock.lockDeviceValidateInforom.RUnlock()
	return calls
}

// DeviceWorkloadPowerProfileClearRequestedProfiles calls DeviceWorkloadPowerProfileClearRequestedProfilesFunc.
func (mock *Interface) DeviceWorkloadPowerProfileClearRequestedProfiles(device nvml.Device, workloadPowerProfileRequestedProfiles *nvml.WorkloadPowerProfileRequestedProfiles) nvml.Return {
	if mock.DeviceWorkloadPowerProfileClearRequestedProfilesFunc == nil {
		panic("Interface.DeviceWorkloadPowerProfileClearRequestedProfilesFunc: method is nil but Interface.DeviceWorkloadPowerProfileClearRequestedProfiles was just called")
	}
	callInfo := struct {
		Device                                nvml.Device
		WorkloadPowerProfileRequestedProfiles *nvml.WorkloadPowerProfileRequestedProfiles
	}{
		Device:                                device,
		WorkloadPowerProfileRequestedProfiles: workloadPowerProfileRequestedProfiles,
	}
	mock.lockDeviceWorkloadPowerProfileClearRequestedProfiles.Lock()
	mock.calls.DeviceWorkloadPowerProfileClearRequestedProfiles = append(mock.calls.DeviceWorkloadPowerProfileClearRequestedProfiles, callInfo)
	mock.lockDeviceWorkloadPowerProfileClearRequestedProfiles.Unlock()
	return mock.DeviceWorkloadPowerProfileClearRequestedProfilesFunc(device, workloadPowerProfileRequestedProfiles)
}

// DeviceWorkloadPowerProfileClearRequestedProfilesCalls gets all the calls that were made to DeviceWorkloadPowerProfileClearRequestedProfiles.
// Check the length with:
//
//	len(mockedInterface.DeviceWorkloadPowerProfileClearRequestedProfilesCalls())
func (mock *Interface) DeviceWorkloadPowerProfileClearRequestedProfilesCalls() []struct {
	Device                                nvml.Device
	WorkloadPowerProfileRequestedProfiles *nvml.WorkloadPowerProfileRequestedProfiles
} {
	var calls []struct {
		Device                                nvml.Device
		WorkloadPowerProfileRequestedProfiles *nvml.WorkloadPowerProfileRequestedProfiles
	}
	mock.lockDeviceWorkloadPowerProfileClearRequestedProfiles.RLock()
	calls = mock.calls.DeviceWorkloadPowerProfileClearRequestedProfiles
	mock.lockDeviceWorkloadPowerProfileClearRequestedProfiles.RUnlock()
	return calls
}

// DeviceWorkloadPowerProfileGetCurrentProfiles calls DeviceWorkloadPowerProfileGetCurrentProfilesFunc.
func (mock *Interface) DeviceWorkloadPowerProfileGetCurrentProfiles(device nvml.Device) (nvml.WorkloadPowerProfileCurrentProfiles, nvml.Return) {
	if mock.DeviceWorkloadPowerProfileGetCurrentProfilesFunc == nil {
		panic("Interface.DeviceWorkloadPowerProfileGetCurrentProfilesFunc: method is nil but Interface.DeviceWorkloadPowerProfileGetCurrentProfiles was just called")
	}
	callInfo := struct {
		Device nvml.Device
	}{
		Device: device,
	}
	mock.lockDeviceWorkloadPowerProfileGetCurrentProfiles.Lock()
	mock.calls.DeviceWorkloadPowerProfileGetCurrentProfiles = append(mock.calls.DeviceWorkloadPowerProfileGetCurrentProfiles, callInfo)
	mock.lockDeviceWorkloadPowerProfileGetCurrentProfiles.Unlock()
	return mock.DeviceWorkloadPowerProfileGetCurrentProfilesFunc(device)
}

// DeviceWorkloadPowerProfileGetCurrentProfilesCalls gets all the calls that were made to DeviceWorkloadPowerProfileGetCurrentProfiles.
// Check the length with:
//
//	len(mockedInterface.DeviceWorkloadPowerProfileGetCurrentProfilesCalls())
func (mock *Interface) DeviceWorkloadPowerProfileGetCurrentProfilesCalls() []struct {
	Device nvml.Device
} {
	var calls []struct {
		Device nvml.Device
	}
	mock.lockDeviceWorkloadPowerProfileGetCurrentProfiles.RLock()
	calls = mock.calls.DeviceWorkloadPowerProfileGetCurrentProfiles
	mock.lockDeviceWorkloadPowerProfileGetCurrentProfiles.RUnlock()
	return calls
}

// DeviceWorkloadPowerProfileGetProfilesInfo calls DeviceWorkloadPowerProfileGetProfilesInfoFunc.
func (mock *Interface) DeviceWorkloadPowerProfileGetProfilesInfo(device nvml.Device) (nvml.WorkloadPowerProfileProfilesInfo, nvml.Return) {
	if mock.DeviceWorkloadPowerProfileGetProfilesInfoFunc == nil {
		panic("Interface.DeviceWorkloadPowerProfileGetProfilesInfoFunc: method is nil but Interface.DeviceWorkloadPowerProfileGetProfilesInfo was just called")
	}
	callInfo := struct {
		Device nvml.Device
	}{
		Device: device,
	}
	mock.lockDeviceWorkloadPowerProfileGetProfilesInfo.Lock()
	mock.calls.DeviceWorkloadPowerProfileGetProfilesInfo = append(mock.calls.DeviceWorkloadPowerProfileGetProfilesInfo, callInfo)
	mock.lockDeviceWorkloadPowerProfileGetProfilesInfo.Unlock()
	return mock.DeviceWorkloadPowerProfileGetProfilesInfoFunc(device)
}

// DeviceWorkloadPowerProfileGetProfilesInfoCalls gets all the calls that were made to DeviceWorkloadPowerProfileGetProfilesInfo.
// Check the length with:
//
//	len(mockedInterface.DeviceWorkloadPowerProfileGetProfilesInfoCalls())
func (mock *Interface) DeviceWorkloadPowerProfileGetProfilesInfoCalls() []struct {
	Device nvml.Device
} {
	var calls []struct {
		Device nvml.Device
	}
	mock.lockDeviceWorkloadPowerProfileGetProfilesInfo.RLock()
	calls = mock.calls.DeviceWorkloadPowerProfileGetProfilesInfo
	mock.lockDeviceWorkloadPowerProfileGetProfilesInfo.RUnlock()
	return calls
}

// DeviceWorkloadPowerProfileSetRequestedProfiles calls DeviceWorkloadPowerProfileSetRequestedProfilesFunc.
func (mock *Interface) DeviceWorkloadPowerProfileSetRequestedProfiles(device nvml.Device, workloadPowerProfileRequestedProfiles *nvml.WorkloadPowerProfileRequestedProfiles) nvml.Return {
	if mock.DeviceWorkloadPowerProfileSetRequestedProfilesFunc == nil {
		panic("Interface.DeviceWorkloadPowerProfileSetRequestedProfilesFunc: method is nil but Interface.DeviceWorkloadPowerProfileSetRequestedProfiles was just called")
	}
	callInfo := struct {
		Device                                nvml.Device
		WorkloadPowerProfileRequestedProfiles *nvml.WorkloadPowerProfileRequestedProfiles
	}{
		Device:                                device,
		WorkloadPowerProfileRequestedProfiles: workloadPowerProfileRequestedProfiles,
	}
	mock.lockDeviceWorkloadPowerProfileSetRequestedProfiles.Lock()
	mock.calls.DeviceWorkloadPowerProfileSetRequestedProfiles = append(mock.calls.DeviceWorkloadPowerProfileSetRequestedProfiles, callInfo)
	mock.lockDeviceWorkloadPowerProfileSetRequestedProfiles.Unlock()
	return mock.DeviceWorkloadPowerProfileSetRequestedProfilesFunc(device, workloadPowerProfileRequestedProfiles)
}

// DeviceWorkloadPowerProfileSetRequestedProfilesCalls gets all the calls that were made to DeviceWorkloadPowerProfileSetRequestedProfiles.
// Check the length with:
//
//	len(mockedInterface.DeviceWorkloadPowerProfileSetRequestedProfilesCalls())
func (mock *Interface) DeviceWorkloadPowerProfileSetRequestedProfilesCalls() []struct {
	Device                                nvml.Device
	WorkloadPowerProfileRequestedProfiles *nvml.WorkloadPowerProfileRequestedProfiles
} {
	var calls []struct {
		Device                                nvml.Device
		WorkloadPowerProfileRequestedProfiles *nvml.WorkloadPowerProfileRequestedProfiles
	}
	mock.lockDeviceWorkloadPowerProfileSetRequestedProfiles.RLock()
	calls = mock.calls.DeviceWorkloadPowerProfileSetRequestedProfiles
	mock.lockDeviceWorkloadPowerProfileSetRequestedProfiles.RUnlock()
	return calls
}

// ErrorString calls ErrorStringFunc.
func (mock *Interface) ErrorString(returnMoqParam nvml.Return) string {
	if mock.ErrorStringFunc == nil {
		panic("Interface.ErrorStringFunc: method is nil but Interface.ErrorString was just called")
	}
	callInfo := struct {
		ReturnMoqParam nvml.Return
	}{
		ReturnMoqParam: returnMoqParam,
	}
	mock.lockErrorString.Lock()
	mock.calls.ErrorString = append(mock.calls.ErrorString, callInfo)
	mock.lockErrorString.Unlock()
	return mock.ErrorStringFunc(returnMoqParam)
}

// ErrorStringCalls gets all the calls that were made to ErrorString.
// Check the length with:
//
//	len(mockedInterface.ErrorStringCalls())
func (mock *Interface) ErrorStringCalls() []struct {
	ReturnMoqParam nvml.Return
} {
	var calls []struct {
		ReturnMoqParam nvml.Return
	}
	mock.lockErrorString.RLock()
	calls = mock.calls.ErrorString
	mock.lockErrorString.RUnlock()
	return calls
}

// EventSetCreate calls EventSetCreateFunc.
func (mock *Interface) EventSetCreate() (nvml.EventSet, nvml.Return) {
	if mock.EventSetCreateFunc == nil {
		panic("Interface.EventSetCreateFunc: method is nil but Interface.EventSetCreate was just called")
	}
	callInfo := struct {
	}{}
	mock.lockEventSetCreate.Lock()
	mock.calls.EventSetCreate = append(mock.calls.EventSetCreate, callInfo)
	mock.lockEventSetCreate.Unlock()
	return mock.EventSetCreateFunc()
}

// EventSetCreateCalls gets all the calls that were made to EventSetCreate.
// Check the length with:
//
//	len(mockedInterface.EventSetCreateCalls())
func (mock *Interface) EventSetCreateCalls() []struct {
} {
	var calls []struct {
	}
	mock.lockEventSetCreate.RLock()
	calls = mock.calls.EventSetCreate
	mock.lockEventSetCreate.RUnlock()
	return calls
}

// EventSetFree calls EventSetFreeFunc.
func (mock *Interface) EventSetFree(eventSet nvml.EventSet) nvml.Return {
	if mock.EventSetFreeFunc == nil {
		panic("Interface.EventSetFreeFunc: method is nil but Interface.EventSetFree was just called")
	}
	callInfo := struct {
		EventSet nvml.EventSet
	}{
		EventSet: eventSet,
	}
	mock.lockEventSetFree.Lock()
	mock.calls.EventSetFree = append(mock.calls.EventSetFree, callInfo)
	mock.lockEventSetFree.Unlock()
	return mock.EventSetFreeFunc(eventSet)
}

// EventSetFreeCalls gets all the calls that were made to EventSetFree.
// Check the length with:
//
//	len(mockedInterface.EventSetFreeCalls())
func (mock *Interface) EventSetFreeCalls() []struct {
	EventSet nvml.EventSet
} {
	var calls []struct {
		EventSet nvml.EventSet
	}
	mock.lockEventSetFree.RLock()
	calls = mock.calls.EventSetFree
	mock.lockEventSetFree.RUnlock()
	return calls
}

// EventSetWait calls EventSetWaitFunc.
func (mock *Interface) EventSetWait(eventSet nvml.EventSet, v uint32) (nvml.EventData, nvml.Return) {
	if mock.EventSetWaitFunc == nil {
		panic("Interface.EventSetWaitFunc: method is nil but Interface.EventSetWait was just called")
	}
	callInfo := struct {
		EventSet nvml.EventSet
		V        uint32
	}{
		EventSet: eventSet,
		V:        v,
	}
	mock.lockEventSetWait.Lock()
	mock.calls.EventSetWait = append(mock.calls.EventSetWait, callInfo)
	mock.lockEventSetWait.Unlock()
	return mock.EventSetWaitFunc(eventSet, v)
}

// EventSetWaitCalls gets all the calls that were made to EventSetWait.
// Check the length with:
//
//	len(mockedInterface.EventSetWaitCalls())
func (mock *Interface) EventSetWaitCalls() []struct {
	EventSet nvml.EventSet
	V        uint32
} {
	var calls []struct {
		EventSet nvml.EventSet
		V        uint32
	}
	mock.lockEventSetWait.RLock()
	calls = mock.calls.EventSetWait
	mock.lockEventSetWait.RUnlock()
	return calls
}

// Extensions calls ExtensionsFunc.
func (mock *Interface) Extensions() nvml.ExtendedInterface {
	if mock.ExtensionsFunc == nil {
		panic("Interface.ExtensionsFunc: method is nil but Interface.Extensions was just called")
	}
	callInfo := struct {
	}{}
	mock.lockExtensions.Lock()
	mock.calls.Extensions = append(mock.calls.Extensions, callInfo)
	mock.lockExtensions.Unlock()
	return mock.ExtensionsFunc()
}

// ExtensionsCalls gets all the calls that were made to Extensions.
// Check the length with:
//
//	len(mockedInterface.ExtensionsCalls())
func (mock *Interface) ExtensionsCalls() []struct {
} {
	var calls []struct {
	}
	mock.lockExtensions.RLock()
	calls = mock.calls.Extensions
	mock.lockExtensions.RUnlock()
	return calls
}

// GetExcludedDeviceCount calls GetExcludedDeviceCountFunc.
func (mock *Interface) GetExcludedDeviceCount() (int, nvml.Return) {
	if mock.GetExcludedDeviceCountFunc == nil {
		panic("Interface.GetExcludedDeviceCountFunc: method is nil but Interface.GetExcludedDeviceCount was just called")
	}
	callInfo := struct {
	}{}
	mock.lockGetExcludedDeviceCount.Lock()
	mock.calls.GetExcludedDeviceCount = append(mock.calls.GetExcludedDeviceCount, callInfo)
	mock.lockGetExcludedDeviceCount.Unlock()
	return mock.GetExcludedDeviceCountFunc()
}

// GetExcludedDeviceCountCalls gets all the calls that were made to GetExcludedDeviceCount.
// Check the length with:
//
//	len(mockedInterface.GetExcludedDeviceCountCalls())
func (mock *Interface) GetExcludedDeviceCountCalls() []struct {
} {
	var calls []struct {
	}
	mock.lockGetExcludedDeviceCount.RLock()
	calls = mock.calls.GetExcludedDeviceCount
	mock.lockGetExcludedDeviceCount.RUnlock()
	return calls
}

// GetExcludedDeviceInfoByIndex calls GetExcludedDeviceInfoByIndexFunc.
func (mock *Interface) GetExcludedDeviceInfoByIndex(n int) (nvml.ExcludedDeviceInfo, nvml.Return) {
	if mock.GetExcludedDeviceInfoByIndexFunc == nil {
		panic("Interface.GetExcludedDeviceInfoByIndexFunc: method is nil but Interface.GetExcludedDeviceInfoByIndex was just called")
	}
	callInfo := struct {
		N int
	}{
		N: n,
	}
	mock.lockGetExcludedDeviceInfoByIndex.Lock()
	mock.calls.GetExcludedDeviceInfoByIndex = append(mock.calls.GetExcludedDeviceInfoByIndex, callInfo)
	mock.lockGetExcludedDeviceInfoByIndex.Unlock()
	return mock.GetExcludedDeviceInfoByIndexFunc(n)
}

// GetExcludedDeviceInfoByIndexCalls gets all the calls that were made to GetExcludedDeviceInfoByIndex.
// Check the length with:
//
//	len(mockedInterface.GetExcludedDeviceInfoByIndexCalls())
func (mock *Interface) GetExcludedDeviceInfoByIndexCalls() []struct {
	N int
} {
	var calls []struct {
		N int
	}
	mock.lockGetExcludedDeviceInfoByIndex.RLock()
	calls = mock.calls.GetExcludedDeviceInfoByIndex
	mock.lockGetExcludedDeviceInfoByIndex.RUnlock()
	return calls
}

// GetVgpuCompatibility calls GetVgpuCompatibilityFunc.
func (mock *Interface) GetVgpuCompatibility(vgpuMetadata *nvml.VgpuMetadata, vgpuPgpuMetadata *nvml.VgpuPgpuMetadata) (nvml.VgpuPgpuCompatibility, nvml.Return) {
	if mock.GetVgpuCompatibilityFunc == nil {
		panic("Interface.GetVgpuCompatibilityFunc: method is nil but Interface.GetVgpuCompatibility was just called")
	}
	callInfo := struct {
		VgpuMetadata     *nvml.VgpuMetadata
		VgpuPgpuMetadata *nvml.VgpuPgpuMetadata
	}{
		VgpuMetadata:     vgpuMetadata,
		VgpuPgpuMetadata: vgpuPgpuMetadata,
	}
	mock.lockGetVgpuCompatibility.Lock()
	mock.calls.GetVgpuCompatibility = append(mock.calls.GetVgpuCompatibility, callInfo)
	mock.lockGetVgpuCompatibility.Unlock()
	return mock.GetVgpuCompatibilityFunc(vgpuMetadata, vgpuPgpuMetadata)
}

// GetVgpuCompatibilityCalls gets all the calls that were made to GetVgpuCompatibility.
// Check the length with:
//
//	len(mockedInterface.GetVgpuCompatibilityCalls())
func (mock *Interface) GetVgpuCompatibilityCalls() []struct {
	VgpuMetadata     *nvml.VgpuMetadata
	VgpuPgpuMetadata *nvml.VgpuPgpuMetadata
} {
	var calls []struct {
		VgpuMetadata     *nvml.VgpuMetadata
		VgpuPgpuMetadata *nvml.VgpuPgpuMetadata
	}
	mock.lockGetVgpuCompatibility.RLock()
	calls = mock.calls.GetVgpuCompatibility
	mock.lockGetVgpuCompatibility.RUnlock()
	return calls
}

// GetVgpuDriverCapabilities calls GetVgpuDriverCapabilitiesFunc.
func (mock *Interface) GetVgpuDriverCapabilities(vgpuDriverCapability nvml.VgpuDriverCapability) (bool, nvml.Return) {
	if mock.GetVgpuDriverCapabilitiesFunc == nil {
		panic("Interface.GetVgpuDriverCapabilitiesFunc: method is nil but Interface.GetVgpuDriverCapabilities was just called")
	}
	callInfo := struct {
		VgpuDriverCapability nvml.VgpuDriverCapability
	}{
		VgpuDriverCapability: vgpuDriverCapability,
	}
	mock.lockGetVgpuDriverCapabilities.Lock()
	mock.calls.GetVgpuDriverCapabilities = append(mock.calls.GetVgpuDriverCapabilities, callInfo)
	mock.lockGetVgpuDriverCapabilities.Unlock()
	return mock.GetVgpuDriverCapabilitiesFunc(vgpuDriverCapability)
}

// GetVgpuDriverCapabilitiesCalls gets all the calls that were made to GetVgpuDriverCapabilities.
// Check the length with:
//
//	len(mockedInterface.GetVgpuDriverCapabilitiesCalls())
func (mock *Interface) GetVgpuDriverCapabilitiesCalls() []struct {
	VgpuDriverCapability nvml.VgpuDriverCapability
} {
	var calls []struct {
		VgpuDriverCapability nvml.VgpuDriverCapability
	}
	mock.lockGetVgpuDriverCapabilities.RLock()
	calls = mock.calls.GetVgpuDriverCapabilities
	mock.lockGetVgpuDriverCapabilities.RUnlock()
	return calls
}

// GetVgpuVersion calls GetVgpuVersionFunc.
func (mock *Interface) GetVgpuVersion() (nvml.VgpuVersion, nvml.VgpuVersion, nvml.Return) {
	if mock.GetVgpuVersionFunc == nil {
		panic("Interface.GetVgpuVersionFunc: method is nil but Interface.GetVgpuVersion was just called")
	}
	callInfo := struct {
	}{}
	mock.lockGetVgpuVersion.Lock()
	mock.calls.GetVgpuVersion = append(mock.calls.GetVgpuVersion, callInfo)
	mock.lockGetVgpuVersion.Unlock()
	return mock.GetVgpuVersionFunc()
}

// GetVgpuVersionCalls gets all the calls that were made to GetVgpuVersion.
// Check the length with:
//
//	len(mockedInterface.GetVgpuVersionCalls())
func (mock *Interface) GetVgpuVersionCalls() []struct {
} {
	var calls []struct {
	}
	mock.lockGetVgpuVersion.RLock()
	calls = mock.calls.GetVgpuVersion
	mock.lockGetVgpuVersion.RUnlock()
	return calls
}

// GpmMetricsGet calls GpmMetricsGetFunc.
func (mock *Interface) GpmMetricsGet(gpmMetricsGetType *nvml.GpmMetricsGetType) nvml.Return {
	if mock.GpmMetricsGetFunc == nil {
		panic("Interface.GpmMetricsGetFunc: method is nil but Interface.GpmMetricsGet was just called")
	}
	callInfo := struct {
		GpmMetricsGetType *nvml.GpmMetricsGetType
	}{
		GpmMetricsGetType: gpmMetricsGetType,
	}
	mock.lockGpmMetricsGet.Lock()
	mock.calls.GpmMetricsGet = append(mock.calls.GpmMetricsGet, callInfo)
	mock.lockGpmMetricsGet.Unlock()
	return mock.GpmMetricsGetFunc(gpmMetricsGetType)
}

// GpmMetricsGetCalls gets all the calls that were made to GpmMetricsGet.
// Check the length with:
//
//	len(mockedInterface.GpmMetricsGetCalls())
func (mock *Interface) GpmMetricsGetCalls() []struct {
	GpmMetricsGetType *nvml.GpmMetricsGetType
} {
	var calls []struct {
		GpmMetricsGetType *nvml.GpmMetricsGetType
	}
	mock.lockGpmMetricsGet.RLock()
	calls = mock.calls.GpmMetricsGet
	mock.lockGpmMetricsGet.RUnlock()
	return calls
}

// GpmMetricsGetV calls GpmMetricsGetVFunc.
func (mock *Interface) GpmMetricsGetV(gpmMetricsGetType *nvml.GpmMetricsGetType) nvml.GpmMetricsGetVType {
	if mock.GpmMetricsGetVFunc == nil {
		panic("Interface.GpmMetricsGetVFunc: method is nil but Interface.GpmMetricsGetV was just called")
	}
	callInfo := struct {
		GpmMetricsGetType *nvml.GpmMetricsGetType
	}{
		GpmMetricsGetType: gpmMetricsGetType,
	}
	mock.lockGpmMetricsGetV.Lock()
	mock.calls.GpmMetricsGetV = append(mock.calls.GpmMetricsGetV, callInfo)
	mock.lockGpmMetricsGetV.Unlock()
	return mock.GpmMetricsGetVFunc(gpmMetricsGetType)
}

// GpmMetricsGetVCalls gets all the calls that were made to GpmMetricsGetV.
// Check the length with:
//
//	len(mockedInterface.GpmMetricsGetVCalls())
func (mock *Interface) GpmMetricsGetVCalls() []struct {
	GpmMetricsGetType *nvml.GpmMetricsGetType
} {
	var calls []struct {
		GpmMetricsGetType *nvml.GpmMetricsGetType
	}
	mock.lockGpmMetricsGetV.RLock()
	calls = mock.calls.GpmMetricsGetV
	mock.lockGpmMetricsGetV.RUnlock()
	return calls
}

// GpmMigSampleGet calls GpmMigSampleGetFunc.
func (mock *Interface) GpmMigSampleGet(device nvml.Device, n int, gpmSample nvml.GpmSample) nvml.Return {
	if mock.GpmMigSampleGetFunc == nil {
		panic("Interface.GpmMigSampleGetFunc: method is nil but Interface.GpmMigSampleGet was just called")
	}
	callInfo := struct {
		Device    nvml.Device
		N         int
		GpmSample nvml.GpmSample
	}{
		Device:    device,
		N:         n,
		GpmSample: gpmSample,
	}
	mock.lockGpmMigSampleGet.Lock()
	mock.calls.GpmMigSampleGet = append(mock.calls.GpmMigSampleGet, callInfo)
	mock.lockGpmMigSampleGet.Unlock()
	return mock.GpmMigSampleGetFunc(device, n, gpmSample)
}

// GpmMigSampleGetCalls gets all the calls that were made to GpmMigSampleGet.
// Check the length with:
//
//	len(mockedInterface.GpmMigSampleGetCalls())
func (mock *Interface) GpmMigSampleGetCalls() []struct {
	Device    nvml.Device
	N         int
	GpmSample nvml.GpmSample
} {
	var calls []struct {
		Device    nvml.Device
		N         int
		GpmSample nvml.GpmSample
	}
	mock.lockGpmMigSampleGet.RLock()
	calls = mock.calls.GpmMigSampleGet
	mock.lockGpmMigSampleGet.RUnlock()
	return calls
}

// GpmQueryDeviceSupport calls GpmQueryDeviceSupportFunc.
func (mock *Interface) GpmQueryDeviceSupport(device nvml.Device) (nvml.GpmSupport, nvml.Return) {
	if mock.GpmQueryDeviceSupportFunc == nil {
		panic("Interface.GpmQueryDeviceSupportFunc: method is nil but Interface.GpmQueryDeviceSupport was just called")
	}
	callInfo := struct {
		Device nvml.Device
	}{
		Device: device,
	}
	mock.lockGpmQueryDeviceSupport.Lock()
	mock.calls.GpmQueryDeviceSupport = append(mock.calls.GpmQueryDeviceSupport, callInfo)
	mock.lockGpmQueryDeviceSupport.Unlock()
	return mock.GpmQueryDeviceSupportFunc(device)
}

// GpmQueryDeviceSupportCalls gets all the calls that were made to GpmQueryDeviceSupport.
// Check the length with:
//
//	len(mockedInterface.GpmQueryDeviceSupportCalls())
func (mock *Interface) GpmQueryDeviceSupportCalls() []struct {
	Device nvml.Device
} {
	var calls []struct {
		Device nvml.Device
	}
	mock.lockGpmQueryDeviceSupport.RLock()
	calls = mock.calls.GpmQueryDeviceSupport
	mock.lockGpmQueryDeviceSupport.RUnlock()
	return calls
}

// GpmQueryDeviceSupportV calls GpmQueryDeviceSupportVFunc.
func (mock *Interface) GpmQueryDeviceSupportV(device nvml.Device) nvml.GpmSupportV {
	if mock.GpmQueryDeviceSupportVFunc == nil {
		panic("Interface.GpmQueryDeviceSupportVFunc: method is nil but Interface.GpmQueryDeviceSupportV was just called")
	}
	callInfo := struct {
		Device nvml.Device
	}{
		Device: device,
	}
	mock.lockGpmQueryDeviceSupportV.Lock()
	mock.calls.GpmQueryDeviceSupportV = append(mock.calls.GpmQueryDeviceSupportV, callInfo)
	mock.lockGpmQueryDeviceSupportV.Unlock()
	return mock.GpmQueryDeviceSupportVFunc(device)
}

// GpmQueryDeviceSupportVCalls gets all the calls that were made to GpmQueryDeviceSupportV.
// Check the length with:
//
//	len(mockedInterface.GpmQueryDeviceSupportVCalls())
func (mock *Interface) GpmQueryDeviceSupportVCalls() []struct {
	Device nvml.Device
} {
	var calls []struct {
		Device nvml.Device
	}
	mock.lockGpmQueryDeviceSupportV.RLock()
	calls = mock.calls.GpmQueryDeviceSupportV
	mock.lockGpmQueryDeviceSupportV.RUnlock()
	return calls
}

// GpmQueryIfStreamingEnabled calls GpmQueryIfStreamingEnabledFunc.
func (mock *Interface) GpmQueryIfStreamingEnabled(device nvml.Device) (uint32, nvml.Return) {
	if mock.GpmQueryIfStreamingEnabledFunc == nil {
		panic("Interface.GpmQueryIfStreamingEnabledFunc: method is nil but Interface.GpmQueryIfStreamingEnabled was just called")
	}
	callInfo := struct {
		Device nvml.Device
	}{
		Device: device,
	}
	mock.lockGpmQueryIfStreamingEnabled.Lock()
	mock.calls.GpmQueryIfStreamingEnabled = append(mock.calls.GpmQueryIfStreamingEnabled, callInfo)
	mock.lockGpmQueryIfStreamingEnabled.Unlock()
	return mock.GpmQueryIfStreamingEnabledFunc(device)
}

// GpmQueryIfStreamingEnabledCalls gets all the calls that were made to GpmQueryIfStreamingEnabled.
// Check the length with:
//
//	len(mockedInterface.GpmQueryIfStreamingEnabledCalls())
func (mock *Interface) GpmQueryIfStreamingEnabledCalls() []struct {
	Device nvml.Device
} {
	var calls []struct {
		Device nvml.Device
	}
	mock.lockGpmQueryIfStreamingEnabled.RLock()
	calls = mock.calls.GpmQueryIfStreamingEnabled
	mock.lockGpmQueryIfStreamingEnabled.RUnlock()
	return calls
}

// GpmSampleAlloc calls GpmSampleAllocFunc.
func (mock *Interface) GpmSampleAlloc() (nvml.GpmSample, nvml.Return) {
	if mock.GpmSampleAllocFunc == nil {
		panic("Interface.GpmSampleAllocFunc: method is nil but Interface.GpmSampleAlloc was just called")
	}
	callInfo := struct {
	}{}
	mock.lockGpmSampleAlloc.Lock()
	mock.calls.GpmSampleAlloc = append(mock.calls.GpmSampleAlloc, callInfo)
	mock.lockGpmSampleAlloc.Unlock()
	return mock.GpmSampleAllocFunc()
}

// GpmSampleAllocCalls gets all the calls that were made to GpmSampleAlloc.
// Check the length with:
//
//	len(mockedInterface.GpmSampleAllocCalls())
func (mock *Interface) GpmSampleAllocCalls() []struct {
} {
	var calls []struct {
	}
	mock.lockGpmSampleAlloc.RLock()
	calls = mock.calls.GpmSampleAlloc
	mock.lockGpmSampleAlloc.RUnlock()
	return calls
}

// GpmSampleFree calls GpmSampleFreeFunc.
func (mock *Interface) GpmSampleFree(gpmSample nvml.GpmSample) nvml.Return {
	if mock.GpmSampleFreeFunc == nil {
		panic("Interface.GpmSampleFreeFunc: method is nil but Interface.GpmSampleFree was just called")
	}
	callInfo := struct {
		GpmSample nvml.GpmSample
	}{
		GpmSample: gpmSample,
	}
	mock.lockGpmSampleFree.Lock()
	mock.calls.GpmSampleFree = append(mock.calls.GpmSampleFree, callInfo)
	mock.lockGpmSampleFree.Unlock()
	return mock.GpmSampleFreeFunc(gpmSample)
}

// GpmSampleFreeCalls gets all the calls that were made to GpmSampleFree.
// Check the length with:
//
//	len(mockedInterface.GpmSampleFreeCalls())
func (mock *Interface) GpmSampleFreeCalls() []struct {
	GpmSample nvml.GpmSample
} {
	var calls []struct {
		GpmSample nvml.GpmSample
	}
	mock.lockGpmSampleFree.RLock()
	calls = mock.calls.GpmSampleFree
	mock.lockGpmSampleFree.RUnlock()
	return calls
}

// GpmSampleGet calls GpmSampleGetFunc.
func (mock *Interface) GpmSampleGet(device nvml.Device, gpmSample nvml.GpmSample) nvml.Return {
	if mock.GpmSampleGetFunc == nil {
		panic("Interface.GpmSampleGetFunc: method is nil but Interface.GpmSampleGet was just called")
	}
	callInfo := struct {
		Device    nvml.Device
		GpmSample nvml.GpmSample
	}{
		Device:    device,
		GpmSample: gpmSample,
	}
	mock.lockGpmSampleGet.Lock()
	mock.calls.GpmSampleGet = append(mock.calls.GpmSampleGet, callInfo)
	mock.lockGpmSampleGet.Unlock()
	return mock.GpmSampleGetFunc(device, gpmSample)
}

// GpmSampleGetCalls gets all the calls that were made to GpmSampleGet.
// Check the length with:
//
//	len(mockedInterface.GpmSampleGetCalls())
func (mock *Interface) GpmSampleGetCalls() []struct {
	Device    nvml.Device
	GpmSample nvml.GpmSample
} {
	var calls []struct {
		Device    nvml.Device
		GpmSample nvml.GpmSample
	}
	mock.lockGpmSampleGet.RLock()
	calls = mock.calls.GpmSampleGet
	mock.lockGpmSampleGet.RUnlock()
	return calls
}

// GpmSetStreamingEnabled calls GpmSetStreamingEnabledFunc.
func (mock *Interface) GpmSetStreamingEnabled(device nvml.Device, v uint32) nvml.Return {
	if mock.GpmSetStreamingEnabledFunc == nil {
		panic("Interface.GpmSetStreamingEnabledFunc: method is nil but Interface.GpmSetStreamingEnabled was just called")
	}
	callInfo := struct {
		Device nvml.Device
		V      uint32
	}{
		Device: device,
		V:      v,
	}
	mock.lockGpmSetStreamingEnabled.Lock()
	mock.calls.GpmSetStreamingEnabled = append(mock.calls.GpmSetStreamingEnabled, callInfo)
	mock.lockGpmSetStreamingEnabled.Unlock()
	return mock.GpmSetStreamingEnabledFunc(device, v)
}

// GpmSetStreamingEnabledCalls gets all the calls that were made to GpmSetStreamingEnabled.
// Check the length with:
//
//	len(mockedInterface.GpmSetStreamingEnabledCalls())
func (mock *Interface) GpmSetStreamingEnabledCalls() []struct {
	Device nvml.Device
	V      uint32
} {
	var calls []struct {
		Device nvml.Device
		V      uint32
	}
	mock.lockGpmSetStreamingEnabled.RLock()
	calls = mock.calls.GpmSetStreamingEnabled
	mock.lockGpmSetStreamingEnabled.RUnlock()
	return calls
}

// GpuInstanceCreateComputeInstance calls GpuInstanceCreateComputeInstanceFunc.
func (mock *Interface) GpuInstanceCreateComputeInstance(gpuInstance nvml.GpuInstance, computeInstanceProfileInfo *nvml.ComputeInstanceProfileInfo) (nvml.ComputeInstance, nvml.Return) {
	if mock.GpuInstanceCreateComputeInstanceFunc == nil {
		panic("Interface.GpuInstanceCreateComputeInstanceFunc: method is nil but Interface.GpuInstanceCreateComputeInstance was just called")
	}
	callInfo := struct {
		GpuInstance                nvml.GpuInstance
		ComputeInstanceProfileInfo *nvml.ComputeInstanceProfileInfo
	}{
		GpuInstance:                gpuInstance,
		ComputeInstanceProfileInfo: computeInstanceProfileInfo,
	}
	mock.lockGpuInstanceCreateComputeInstance.Lock()
	mock.calls.GpuInstanceCreateComputeInstance = append(mock.calls.GpuInstanceCreateComputeInstance, callInfo)
	mock.lockGpuInstanceCreateComputeInstance.Unlock()
	return mock.GpuInstanceCreateComputeInstanceFunc(gpuInstance, computeInstanceProfileInfo)
}

// GpuInstanceCreateComputeInstanceCalls gets all the calls that were made to GpuInstanceCreateComputeInstance.
// Check the length with:
//
//	len(mockedInterface.GpuInstanceCreateComputeInstanceCalls())
func (mock *Interface) GpuInstanceCreateComputeInstanceCalls() []struct {
	GpuInstance                nvml.GpuInstance
	ComputeInstanceProfileInfo *nvml.ComputeInstanceProfileInfo
} {
	var calls []struct {
		GpuInstance                nvml.GpuInstance
		ComputeInstanceProfileInfo *nvml.ComputeInstanceProfileInfo
	}
	mock.lockGpuInstanceCreateComputeInstance.RLock()
	calls = mock.calls.GpuInstanceCreateComputeInstance
	mock.lockGpuInstanceCreateComputeInstance.RUnlock()
	return calls
}

// GpuInstanceCreateComputeInstanceWithPlacement calls GpuInstanceCreateComputeInstanceWithPlacementFunc.
func (mock *Interface) GpuInstanceCreateComputeInstanceWithPlacement(gpuInstance nvml.GpuInstance, computeInstanceProfileInfo *nvml.ComputeInstanceProfileInfo, computeInstancePlacement *nvml.ComputeInstancePlacement) (nvml.ComputeInstance, nvml.Return) {
	if mock.GpuInstanceCreateComputeInstanceWithPlacementFunc == nil {
		panic("Interface.GpuInstanceCreateComputeInstanceWithPlacementFunc: method is nil but Interface.GpuInstanceCreateComputeInstanceWithPlacement was just called")
	}
	callInfo := struct {
		GpuInstance                nvml.GpuInstance
		ComputeInstanceProfileInfo *nvml.ComputeInstanceProfileInfo
		ComputeInstancePlacement   *nvml.ComputeInstancePlacement
	}{
		GpuInstance:                gpuInstance,
		ComputeInstanceProfileInfo: computeInstanceProfileInfo,
		ComputeInstancePlacement:   computeInstancePlacement,
	}
	mock.lockGpuInstanceCreateComputeInstanceWithPlacement.Lock()
	mock.calls.GpuInstanceCreateComputeInstanceWithPlacement = append(mock.calls.GpuInstanceCreateComputeInstanceWithPlacement, callInfo)
	mock.lockGpuInstanceCreateComputeInstanceWithPlacement.Unlock()
	return mock.GpuInstanceCreateComputeInstanceWithPlacementFunc(gpuInstance, computeInstanceProfileInfo, computeInstancePlacement)
}

// GpuInstanceCreateComputeInstanceWithPlacementCalls gets all the calls that were made to GpuInstanceCreateComputeInstanceWithPlacement.
// Check the length with:
//
//	len(mockedInterface.GpuInstanceCreateComputeInstanceWithPlacementCalls())
func (mock *Interface) GpuInstanceCreateComputeInstanceWithPlacementCalls() []struct {
	GpuInstance                nvml.GpuInstance
	ComputeInstanceProfileInfo *nvml.ComputeInstanceProfileInfo
	ComputeInstancePlacement   *nvml.ComputeInstancePlacement
} {
	var calls []struct {
		GpuInstance                nvml.GpuInstance
		ComputeInstanceProfileInfo *nvml.ComputeInstanceProfileInfo
		ComputeInstancePlacement   *nvml.ComputeInstancePlacement
	}
	mock.lockGpuInstanceCreateComputeInstanceWithPlacement.RLock()
	calls = mock.calls.GpuInstanceCreateComputeInstanceWithPlacement
	mock.lockGpuInstanceCreateComputeInstanceWithPlacement.RUnlock()
	return calls
}

// GpuInstanceDestroy calls GpuInstanceDestroyFunc.
func (mock *Interface) GpuInstanceDestroy(gpuInstance nvml.GpuInstance) nvml.Return {
	if mock.GpuInstanceDestroyFunc == nil {
		panic("Interface.GpuInstanceDestroyFunc: method is nil but Interface.GpuInstanceDestroy was just called")
	}
	callInfo := struct {
		GpuInstance nvml.GpuInstance
	}{
		GpuInstance: gpuInstance,
	}
	mock.lockGpuInstanceDestroy.Lock()
	mock.calls.GpuInstanceDestroy = append(mock.calls.GpuInstanceDestroy, callInfo)
	mock.lockGpuInstanceDestroy.Unlock()
	return mock.GpuInstanceDestroyFunc(gpuInstance)
}

// GpuInstanceDestroyCalls gets all the calls that were made to GpuInstanceDestroy.
// Check the length with:
//
//	len(mockedInterface.GpuInstanceDestroyCalls())
func (mock *Interface) GpuInstanceDestroyCalls() []struct {
	GpuInstance nvml.GpuInstance
} {
	var calls []struct {
		GpuInstance nvml.GpuInstance
	}
	mock.lockGpuInstanceDestroy.RLock()
	calls = mock.calls.GpuInstanceDestroy
	mock.lockGpuInstanceDestroy.RUnlock()
	return calls
}

// GpuInstanceGetActiveVgpus calls GpuInstanceGetActiveVgpusFunc.
func (mock *Interface) GpuInstanceGetActiveVgpus(gpuInstance nvml.GpuInstance) (nvml.ActiveVgpuInstanceInfo, nvml.Return) {
	if mock.GpuInstanceGetActiveVgpusFunc == nil {
		panic("Interface.GpuInstanceGetActiveVgpusFunc: method is nil but Interface.GpuInstanceGetActiveVgpus was just called")
	}
	callInfo := struct {
		GpuInstance nvml.GpuInstance
	}{
		GpuInstance: gpuInstance,
	}
	mock.lockGpuInstanceGetActiveVgpus.Lock()
	mock.calls.GpuInstanceGetActiveVgpus = append(mock.calls.GpuInstanceGetActiveVgpus, callInfo)
	mock.lockGpuInstanceGetActiveVgpus.Unlock()
	return mock.GpuInstanceGetActiveVgpusFunc(gpuInstance)
}

// GpuInstanceGetActiveVgpusCalls gets all the calls that were made to GpuInstanceGetActiveVgpus.
// Check the length with:
//
//	len(mockedInterface.GpuInstanceGetActiveVgpusCalls())
func (mock *Interface) GpuInstanceGetActiveVgpusCalls() []struct {
	GpuInstance nvml.GpuInstance
} {
	var calls []struct {
		GpuInstance nvml.GpuInstance
	}
	mock.lockGpuInstanceGetActiveVgpus.RLock()
	calls = mock.calls.GpuInstanceGetActiveVgpus
	mock.lockGpuInstanceGetActiveVgpus.RUnlock()
	return calls
}

// GpuInstanceGetComputeInstanceById calls GpuInstanceGetComputeInstanceByIdFunc.
func (mock *Interface) GpuInstanceGetComputeInstanceById(gpuInstance nvml.GpuInstance, n int) (nvml.ComputeInstance, nvml.Return) {
	if mock.GpuInstanceGetComputeInstanceByIdFunc == nil {
		panic("Interface.GpuInstanceGetComputeInstanceByIdFunc: method is nil but Interface.GpuInstanceGetComputeInstanceById was just called")
	}
	callInfo := struct {
		GpuInstance nvml.GpuInstance
		N           int
	}{
		GpuInstance: gpuInstance,
		N:           n,
	}
	mock.lockGpuInstanceGetComputeInstanceById.Lock()
	mock.calls.GpuInstanceGetComputeInstanceById = append(mock.calls.GpuInstanceGetComputeInstanceById, callInfo)
	mock.lockGpuInstanceGetComputeInstanceById.Unlock()
	return mock.GpuInstanceGetComputeInstanceByIdFunc(gpuInstance, n)
}

// GpuInstanceGetComputeInstanceByIdCalls gets all the calls that were made to GpuInstanceGetComputeInstanceById.
// Check the length with:
//
//	len(mockedInterface.GpuInstanceGetComputeInstanceByIdCalls())
func (mock *Interface) GpuInstanceGetComputeInstanceByIdCalls() []struct {
	GpuInstance nvml.GpuInstance
	N           int
} {
	var calls []struct {
		GpuInstance nvml.GpuInstance
		N           int
	}
	mock.lockGpuInstanceGetComputeInstanceById.RLock()
	calls = mock.calls.GpuInstanceGetComputeInstanceById
	mock.lockGpuInstanceGetComputeInstanceById.RUnlock()
	return calls
}

// GpuInstanceGetComputeInstancePossiblePlacements calls GpuInstanceGetComputeInstancePossiblePlacementsFunc.
func (mock *Interface) GpuInstanceGetComputeInstancePossiblePlacements(gpuInstance nvml.GpuInstance, computeInstanceProfileInfo *nvml.ComputeInstanceProfileInfo) ([]nvml.ComputeInstancePlacement, nvml.Return) {
	if mock.GpuInstanceGetComputeInstancePossiblePlacementsFunc == nil {
		panic("Interface.GpuInstanceGetComputeInstancePossiblePlacementsFunc: method is nil but Interface.GpuInstanceGetComputeInstancePossiblePlacements was just called")
	}
	callInfo := struct {
		GpuInstance                nvml.GpuInstance
		ComputeInstanceProfileInfo *nvml.ComputeInstanceProfileInfo
	}{
		GpuInstance:                gpuInstance,
		ComputeInstanceProfileInfo: computeInstanceProfileInfo,
	}
	mock.lockGpuInstanceGetComputeInstancePossiblePlacements.Lock()
	mock.calls.GpuInstanceGetComputeInstancePossiblePlacements = append(mock.calls.GpuInstanceGetComputeInstancePossiblePlacements, callInfo)
	mock.lockGpuInstanceGetComputeInstancePossiblePlacements.Unlock()
	return mock.GpuInstanceGetComputeInstancePossiblePlacementsFunc(gpuInstance, computeInstanceProfileInfo)
}

// GpuInstanceGetComputeInstancePossiblePlacementsCalls gets all the calls that were made to GpuInstanceGetComputeInstancePossiblePlacements.
// Check the length with:
//
//	len(mockedInterface.GpuInstanceGetComputeInstancePossiblePlacementsCalls())
func (mock *Interface) GpuInstanceGetComputeInstancePossiblePlacementsCalls() []struct {
	GpuInstance                nvml.GpuInstance
	ComputeInstanceProfileInfo *nvml.ComputeInstanceProfileInfo
} {
	var calls []struct {
		GpuInstance                nvml.GpuInstance
		ComputeInstanceProfileInfo *nvml.ComputeInstanceProfileInfo
	}
	mock.lockGpuInstanceGetComputeInstancePossiblePlacements.RLock()
	calls = mock.calls.GpuInstanceGetComputeInstancePossiblePlacements
	mock.lockGpuInstanceGetComputeInstancePossiblePlacements.RUnlock()
	return calls
}

// GpuInstanceGetComputeInstanceProfileInfo calls GpuInstanceGetComputeInstanceProfileInfoFunc.
func (mock *Interface) GpuInstanceGetComputeInstanceProfileInfo(gpuInstance nvml.GpuInstance, n1 int, n2 int) (nvml.ComputeInstanceProfileInfo, nvml.Return) {
	if mock.GpuInstanceGetComputeInstanceProfileInfoFunc == nil {
		panic("Interface.GpuInstanceGetComputeInstanceProfileInfoFunc: method is nil but Interface.GpuInstanceGetComputeInstanceProfileInfo was just called")
	}
	callInfo := struct {
		GpuInstance nvml.GpuInstance
		N1          int
		N2          int
	}{
		GpuInstance: gpuInstance,
		N1:          n1,
		N2:          n2,
	}
	mock.lockGpuInstanceGetComputeInstanceProfileInfo.Lock()
	mock.calls.GpuInstanceGetComputeInstanceProfileInfo = append(mock.calls.GpuInstanceGetComputeInstanceProfileInfo, callInfo)
	mock.lockGpuInstanceGetComputeInstanceProfileInfo.Unlock()
	return mock.GpuInstanceGetComputeInstanceProfileInfoFunc(gpuInstance, n1, n2)
}

// GpuInstanceGetComputeInstanceProfileInfoCalls gets all the calls that were made to GpuInstanceGetComputeInstanceProfileInfo.
// Check the length with:
//
//	len(mockedInterface.GpuInstanceGetComputeInstanceProfileInfoCalls())
func (mock *Interface) GpuInstanceGetComputeInstanceProfileInfoCalls() []struct {
	GpuInstance nvml.GpuInstance
	N1          int
	N2          int
} {
	var calls []struct {
		GpuInstance nvml.GpuInstance
		N1          int
		N2          int
	}
	mock.lockGpuInstanceGetComputeInstanceProfileInfo.RLock()
	calls = mock.calls.GpuInstanceGetComputeInstanceProfileInfo
	mock.lockGpuInstanceGetComputeInstanceProfileInfo.RUnlock()
	return calls
}

// GpuInstanceGetComputeInstanceProfileInfoV calls GpuInstanceGetComputeInstanceProfileInfoVFunc.
func (mock *Interface) GpuInstanceGetComputeInstanceProfileInfoV(gpuInstance nvml.GpuInstance, n1 int, n2 int) nvml.ComputeInstanceProfileInfoHandler {
	if mock.GpuInstanceGetComputeInstanceProfileInfoVFunc == nil {
		panic("Interface.GpuInstanceGetComputeInstanceProfileInfoVFunc: method is nil but Interface.GpuInstanceGetComputeInstanceProfileInfoV was just called")
	}
	callInfo := struct {
		GpuInstance nvml.GpuInstance
		N1          int
		N2          int
	}{
		GpuInstance: gpuInstance,
		N1:          n1,
		N2:          n2,
	}
	mock.lockGpuInstanceGetComputeInstanceProfileInfoV.Lock()
	mock.calls.GpuInstanceGetComputeInstanceProfileInfoV = append(mock.calls.GpuInstanceGetComputeInstanceProfileInfoV, callInfo)
	mock.lockGpuInstanceGetComputeInstanceProfileInfoV.Unlock()
	return mock.GpuInstanceGetComputeInstanceProfileInfoVFunc(gpuInstance, n1, n2)
}

// GpuInstanceGetComputeInstanceProfileInfoVCalls gets all the calls that were made to GpuInstanceGetComputeInstanceProfileInfoV.
// Check the length with:
//
//	len(mockedInterface.GpuInstanceGetComputeInstanceProfileInfoVCalls())
func (mock *Interface) GpuInstanceGetComputeInstanceProfileInfoVCalls() []struct {
	GpuInstance nvml.GpuInstance
	N1          int
	N2          int
} {
	var calls []struct {
		GpuInstance nvml.GpuInstance
		N1          int
		N2          int
	}
	mock.lockGpuInstanceGetComputeInstanceProfileInfoV.RLock()
	calls = mock.calls.GpuInstanceGetComputeInstanceProfileInfoV
	mock.lockGpuInstanceGetComputeInstanceProfileInfoV.RUnlock()
	return calls
}

// GpuInstanceGetComputeInstanceRemainingCapacity calls GpuInstanceGetComputeInstanceRemainingCapacityFunc.
func (mock *Interface) GpuInstanceGetComputeInstanceRemainingCapacity(gpuInstance nvml.GpuInstance, computeInstanceProfileInfo *nvml.ComputeInstanceProfileInfo) (int, nvml.Return) {
	if mock.GpuInstanceGetComputeInstanceRemainingCapacityFunc == nil {
		panic("Interface.GpuInstanceGetComputeInstanceRemainingCapacityFunc: method is nil but Interface.GpuInstanceGetComputeInstanceRemainingCapacity was just called")
	}
	callInfo := struct {
		GpuInstance                nvml.GpuInstance
		ComputeInstanceProfileInfo *nvml.ComputeInstanceProfileInfo
	}{
		GpuInstance:                gpuInstance,
		ComputeInstanceProfileInfo: computeInstanceProfileInfo,
	}
	mock.lockGpuInstanceGetComputeInstanceRemainingCapacity.Lock()
	mock.calls.GpuInstanceGetComputeInstanceRemainingCapacity = append(mock.calls.GpuInstanceGetComputeInstanceRemainingCapacity, callInfo)
	mock.lockGpuInstanceGetComputeInstanceRemainingCapacity.Unlock()
	return mock.GpuInstanceGetComputeInstanceRemainingCapacityFunc(gpuInstance, computeInstanceProfileInfo)
}

// GpuInstanceGetComputeInstanceRemainingCapacityCalls gets all the calls that were made to GpuInstanceGetComputeInstanceRemainingCapacity.
// Check the length with:
//
//	len(mockedInterface.GpuInstanceGetComputeInstanceRemainingCapacityCalls())
func (mock *Interface) GpuInstanceGetComputeInstanceRemainingCapacityCalls() []struct {
	GpuInstance                nvml.GpuInstance
	ComputeInstanceProfileInfo *nvml.ComputeInstanceProfileInfo
} {
	var calls []struct {
		GpuInstance                nvml.GpuInstance
		ComputeInstanceProfileInfo *nvml.ComputeInstanceProfileInfo
	}
	mock.lockGpuInstanceGetComputeInstanceRemainingCapacity.RLock()
	calls = mock.calls.GpuInstanceGetComputeInstanceRemainingCapacity
	mock.lockGpuInstanceGetComputeInstanceRemainingCapacity.RUnlock()
	return calls
}

// GpuInstanceGetComputeInstances calls GpuInstanceGetComputeInstancesFunc.
func (mock *Interface) GpuInstanceGetComputeInstances(gpuInstance nvml.GpuInstance, computeInstanceProfileInfo *nvml.ComputeInstanceProfileInfo) ([]nvml.ComputeInstance, nvml.Return) {
	if mock.GpuInstanceGetComputeInstancesFunc == nil {
		panic("Interface.GpuInstanceGetComputeInstancesFunc: method is nil but Interface.GpuInstanceGetComputeInstances was just called")
	}
	callInfo := struct {
		GpuInstance                nvml.GpuInstance
		ComputeInstanceProfileInfo *nvml.ComputeInstanceProfileInfo
	}{
		GpuInstance:                gpuInstance,
		ComputeInstanceProfileInfo: computeInstanceProfileInfo,
	}
	mock.lockGpuInstanceGetComputeInstances.Lock()
	mock.calls.GpuInstanceGetComputeInstances = append(mock.calls.GpuInstanceGetComputeInstances, callInfo)
	mock.lockGpuInstanceGetComputeInstances.Unlock()
	return mock.GpuInstanceGetComputeInstancesFunc(gpuInstance, computeInstanceProfileInfo)
}

// GpuInstanceGetComputeInstancesCalls gets all the calls that were made to GpuInstanceGetComputeInstances.
// Check the length with:
//
//	len(mockedInterface.GpuInstanceGetComputeInstancesCalls())
func (mock *Interface) GpuInstanceGetComputeInstancesCalls() []struct {
	GpuInstance                nvml.GpuInstance
	ComputeInstanceProfileInfo *nvml.ComputeInstanceProfileInfo
} {
	var calls []struct {
		GpuInstance                nvml.GpuInstance
		ComputeInstanceProfileInfo *nvml.ComputeInstanceProfileInfo
	}
	mock.lockGpuInstanceGetComputeInstances.RLock()
	calls = mock.calls.GpuInstanceGetComputeInstances
	mock.lockGpuInstanceGetComputeInstances.RUnlock()
	return calls
}

// GpuInstanceGetCreatableVgpus calls GpuInstanceGetCreatableVgpusFunc.
func (mock *Interface) GpuInstanceGetCreatableVgpus(gpuInstance nvml.GpuInstance) (nvml.VgpuTypeIdInfo, nvml.Return) {
	if mock.GpuInstanceGetCreatableVgpusFunc == nil {
		panic("Interface.GpuInstanceGetCreatableVgpusFunc: method is nil but Interface.GpuInstanceGetCreatableVgpus was just called")
	}
	callInfo := struct {
		GpuInstance nvml.GpuInstance
	}{
		GpuInstance: gpuInstance,
	}
	mock.lockGpuInstanceGetCreatableVgpus.Lock()
	mock.calls.GpuInstanceGetCreatableVgpus = append(mock.calls.GpuInstanceGetCreatableVgpus, callInfo)
	mock.lockGpuInstanceGetCreatableVgpus.Unlock()
	return mock.GpuInstanceGetCreatableVgpusFunc(gpuInstance)
}

// GpuInstanceGetCreatableVgpusCalls gets all the calls that were made to GpuInstanceGetCreatableVgpus.
// Check the length with:
//
//	len(mockedInterface.GpuInstanceGetCreatableVgpusCalls())
func (mock *Interface) GpuInstanceGetCreatableVgpusCalls() []struct {
	GpuInstance nvml.GpuInstance
} {
	var calls []struct {
		GpuInstance nvml.GpuInstance
	}
	mock.lockGpuInstanceGetCreatableVgpus.RLock()
	calls = mock.calls.GpuInstanceGetCreatableVgpus
	mock.lockGpuInstanceGetCreatableVgpus.RUnlock()
	return calls
}

// GpuInstanceGetInfo calls GpuInstanceGetInfoFunc.
func (mock *Interface) GpuInstanceGetInfo(gpuInstance nvml.GpuInstance) (nvml.GpuInstanceInfo, nvml.Return) {
	if mock.GpuInstanceGetInfoFunc == nil {
		panic("Interface.GpuInstanceGetInfoFunc: method is nil but Interface.GpuInstanceGetInfo was just called")
	}
	callInfo := struct {
		GpuInstance nvml.GpuInstance
	}{
		GpuInstance: gpuInstance,
	}
	mock.lockGpuInstanceGetInfo.Lock()
	mock.calls.GpuInstanceGetInfo = append(mock.calls.GpuInstanceGetInfo, callInfo)
	mock.lockGpuInstanceGetInfo.Unlock()
	return mock.GpuInstanceGetInfoFunc(gpuInstance)
}

// GpuInstanceGetInfoCalls gets all the calls that were made to GpuInstanceGetInfo.
// Check the length with:
//
//	len(mockedInterface.GpuInstanceGetInfoCalls())
func (mock *Interface) GpuInstanceGetInfoCalls() []struct {
	GpuInstance nvml.GpuInstance
} {
	var calls []struct {
		GpuInstance nvml.GpuInstance
	}
	mock.lockGpuInstanceGetInfo.RLock()
	calls = mock.calls.GpuInstanceGetInfo
	mock.lockGpuInstanceGetInfo.RUnlock()
	return calls
}

// GpuInstanceGetVgpuHeterogeneousMode calls GpuInstanceGetVgpuHeterogeneousModeFunc.
func (mock *Interface) GpuInstanceGetVgpuHeterogeneousMode(gpuInstance nvml.GpuInstance) (nvml.VgpuHeterogeneousMode, nvml.Return) {
	if mock.GpuInstanceGetVgpuHeterogeneousModeFunc == nil {
		panic("Interface.GpuInstanceGetVgpuHeterogeneousModeFunc: method is nil but Interface.GpuInstanceGetVgpuHeterogeneousMode was just called")
	}
	callInfo := struct {
		GpuInstance nvml.GpuInstance
	}{
		GpuInstance: gpuInstance,
	}
	mock.lockGpuInstanceGetVgpuHeterogeneousMode.Lock()
	mock.calls.GpuInstanceGetVgpuHeterogeneousMode = append(mock.calls.GpuInstanceGetVgpuHeterogeneousMode, callInfo)
	mock.lockGpuInstanceGetVgpuHeterogeneousMode.Unlock()
	return mock.GpuInstanceGetVgpuHeterogeneousModeFunc(gpuInstance)
}

// GpuInstanceGetVgpuHeterogeneousModeCalls gets all the calls that were made to GpuInstanceGetVgpuHeterogeneousMode.
// Check the length with:
//
//	len(mockedInterface.GpuInstanceGetVgpuHeterogeneousModeCalls())
func (mock *Interface) GpuInstanceGetVgpuHeterogeneousModeCalls() []struct {
	GpuInstance nvml.GpuInstance
} {
	var calls []struct {
		GpuInstance nvml.GpuInstance
	}
	mock.lockGpuInstanceGetVgpuHeterogeneousMode.RLock()
	calls = mock.calls.GpuInstanceGetVgpuHeterogeneousMode
	mock.lockGpuInstanceGetVgpuHeterogeneousMode.RUnlock()
	return calls
}

// GpuInstanceGetVgpuSchedulerLog calls GpuInstanceGetVgpuSchedulerLogFunc.
func (mock *Interface) GpuInstanceGetVgpuSchedulerLog(gpuInstance nvml.GpuInstance) (nvml.VgpuSchedulerLogInfo, nvml.Return) {
	if mock.GpuInstanceGetVgpuSchedulerLogFunc == nil {
		panic("Interface.GpuInstanceGetVgpuSchedulerLogFunc: method is nil but Interface.GpuInstanceGetVgpuSchedulerLog was just called")
	}
	callInfo := struct {
		GpuInstance nvml.GpuInstance
	}{
		GpuInstance: gpuInstance,
	}
	mock.lockGpuInstanceGetVgpuSchedulerLog.Lock()
	mock.calls.GpuInstanceGetVgpuSchedulerLog = append(mock.calls.GpuInstanceGetVgpuSchedulerLog, callInfo)
	mock.lockGpuInstanceGetVgpuSchedulerLog.Unlock()
	return mock.GpuInstanceGetVgpuSchedulerLogFunc(gpuInstance)
}

// GpuInstanceGetVgpuSchedulerLogCalls gets all the calls that were made to GpuInstanceGetVgpuSchedulerLog.
// Check the length with:
//
//	len(mockedInterface.GpuInstanceGetVgpuSchedulerLogCalls())
func (mock *Interface) GpuInstanceGetVgpuSchedulerLogCalls() []struct {
	GpuInstance nvml.GpuInstance
} {
	var calls []struct {
		GpuInstance nvml.GpuInstance
	}
	mock.lockGpuInstanceGetVgpuSchedulerLog.RLock()
	calls = mock.calls.GpuInstanceGetVgpuSchedulerLog
	mock.lockGpuInstanceGetVgpuSchedulerLog.RUnlock()
	return calls
}

// GpuInstanceGetVgpuSchedulerState calls GpuInstanceGetVgpuSchedulerStateFunc.
func (mock *Interface) GpuInstanceGetVgpuSchedulerState(gpuInstance nvml.GpuInstance) (nvml.VgpuSchedulerStateInfo, nvml.Return) {
	if mock.GpuInstanceGetVgpuSchedulerStateFunc == nil {
		panic("Interface.GpuInstanceGetVgpuSchedulerStateFunc: method is nil but Interface.GpuInstanceGetVgpuSchedulerState was just called")
	}
	callInfo := struct {
		GpuInstance nvml.GpuInstance
	}{
		GpuInstance: gpuInstance,
	}
	mock.lockGpuInstanceGetVgpuSchedulerState.Lock()
	mock.calls.GpuInstanceGetVgpuSchedulerState = append(mock.calls.GpuInstanceGetVgpuSchedulerState, callInfo)
	mock.lockGpuInstanceGetVgpuSchedulerState.Unlock()
	return mock.GpuInstanceGetVgpuSchedulerStateFunc(gpuInstance)
}

// GpuInstanceGetVgpuSchedulerStateCalls gets all the calls that were made to GpuInstanceGetVgpuSchedulerState.
// Check the length with:
//
//	len(mockedInterface.GpuInstanceGetVgpuSchedulerStateCalls())
func (mock *Interface) GpuInstanceGetVgpuSchedulerStateCalls() []struct {
	GpuInstance nvml.GpuInstance
} {
	var calls []struct {
		GpuInstance nvml.GpuInstance
	}
	mock.lockGpuInstanceGetVgpuSchedulerState.RLock()
	calls = mock.calls.GpuInstanceGetVgpuSchedulerState
	mock.lockGpuInstanceGetVgpuSchedulerState.RUnlock()
	return calls
}

// GpuInstanceGetVgpuTypeCreatablePlacements calls GpuInstanceGetVgpuTypeCreatablePlacementsFunc.
func (mock *Interface) GpuInstanceGetVgpuTypeCreatablePlacements(gpuInstance nvml.GpuInstance) (nvml.VgpuCreatablePlacementInfo, nvml.Return) {
	if mock.GpuInstanceGetVgpuTypeCreatablePlacementsFunc == nil {
		panic("Interface.GpuInstanceGetVgpuTypeCreatablePlacementsFunc: method is nil but Interface.GpuInstanceGetVgpuTypeCreatablePlacements was just called")
	}
	callInfo := struct {
		GpuInstance nvml.GpuInstance
	}{
		GpuInstance: gpuInstance,
	}
	mock.lockGpuInstanceGetVgpuTypeCreatablePlacements.Lock()
	mock.calls.GpuInstanceGetVgpuTypeCreatablePlacements = append(mock.calls.GpuInstanceGetVgpuTypeCreatablePlacements, callInfo)
	mock.lockGpuInstanceGetVgpuTypeCreatablePlacements.Unlock()
	return mock.GpuInstanceGetVgpuTypeCreatablePlacementsFunc(gpuInstance)
}

// GpuInstanceGetVgpuTypeCreatablePlacementsCalls gets all the calls that were made to GpuInstanceGetVgpuTypeCreatablePlacements.
// Check the length with:
//
//	len(mockedInterface.GpuInstanceGetVgpuTypeCreatablePlacementsCalls())
func (mock *Interface) GpuInstanceGetVgpuTypeCreatablePlacementsCalls() []struct {
	GpuInstance nvml.GpuInstance
} {
	var calls []struct {
		GpuInstance nvml.GpuInstance
	}
	mock.lockGpuInstanceGetVgpuTypeCreatablePlacements.RLock()
	calls = mock.calls.GpuInstanceGetVgpuTypeCreatablePlacements
	mock.lockGpuInstanceGetVgpuTypeCreatablePlacements.RUnlock()
	return calls
}

// GpuInstanceSetVgpuHeterogeneousMode calls GpuInstanceSetVgpuHeterogeneousModeFunc.
func (mock *Interface) GpuInstanceSetVgpuHeterogeneousMode(gpuInstance nvml.GpuInstance, vgpuHeterogeneousMode *nvml.VgpuHeterogeneousMode) nvml.Return {
	if mock.GpuInstanceSetVgpuHeterogeneousModeFunc == nil {
		panic("Interface.GpuInstanceSetVgpuHeterogeneousModeFunc: method is nil but Interface.GpuInstanceSetVgpuHeterogeneousMode was just called")
	}
	callInfo := struct {
		GpuInstance           nvml.GpuInstance
		VgpuHeterogeneousMode *nvml.VgpuHeterogeneousMode
	}{
		GpuInstance:           gpuInstance,
		VgpuHeterogeneousMode: vgpuHeterogeneousMode,
	}
	mock.lockGpuInstanceSetVgpuHeterogeneousMode.Lock()
	mock.calls.GpuInstanceSetVgpuHeterogeneousMode = append(mock.calls.GpuInstanceSetVgpuHeterogeneousMode, callInfo)
	mock.lockGpuInstanceSetVgpuHeterogeneousMode.Unlock()
	return mock.GpuInstanceSetVgpuHeterogeneousModeFunc(gpuInstance, vgpuHeterogeneousMode)
}

// GpuInstanceSetVgpuHeterogeneousModeCalls gets all the calls that were made to GpuInstanceSetVgpuHeterogeneousMode.
// Check the length with:
//
//	len(mockedInterface.GpuInstanceSetVgpuHeterogeneousModeCalls())
func (mock *Interface) GpuInstanceSetVgpuHeterogeneousModeCalls() []struct {
	GpuInstance           nvml.GpuInstance
	VgpuHeterogeneousMode *nvml.VgpuHeterogeneousMode
} {
	var calls []struct {
		GpuInstance           nvml.GpuInstance
		VgpuHeterogeneousMode *nvml.VgpuHeterogeneousMode
	}
	mock.lockGpuInstanceSetVgpuHeterogeneousMode.RLock()
	calls = mock.calls.GpuInstanceSetVgpuHeterogeneousMode
	mock.lockGpuInstanceSetVgpuHeterogeneousMode.RUnlock()
	return calls
}

// GpuInstanceSetVgpuSchedulerState calls GpuInstanceSetVgpuSchedulerStateFunc.
func (mock *Interface) GpuInstanceSetVgpuSchedulerState(gpuInstance nvml.GpuInstance, vgpuSchedulerState *nvml.VgpuSchedulerState) nvml.Return {
	if mock.GpuInstanceSetVgpuSchedulerStateFunc == nil {
		panic("Interface.GpuInstanceSetVgpuSchedulerStateFunc: method is nil but Interface.GpuInstanceSetVgpuSchedulerState was just called")
	}
	callInfo := struct {
		GpuInstance        nvml.GpuInstance
		VgpuSchedulerState *nvml.VgpuSchedulerState
	}{
		GpuInstance:        gpuInstance,
		VgpuSchedulerState: vgpuSchedulerState,
	}
	mock.lockGpuInstanceSetVgpuSchedulerState.Lock()
	mock.calls.GpuInstanceSetVgpuSchedulerState = append(mock.calls.GpuInstanceSetVgpuSchedulerState, callInfo)
	mock.lockGpuInstanceSetVgpuSchedulerState.Unlock()
	return mock.GpuInstanceSetVgpuSchedulerStateFunc(gpuInstance, vgpuSchedulerState)
}

// GpuInstanceSetVgpuSchedulerStateCalls gets all the calls that were made to GpuInstanceSetVgpuSchedulerState.
// Check the length with:
//
//	len(mockedInterface.GpuInstanceSetVgpuSchedulerStateCalls())
func (mock *Interface) GpuInstanceSetVgpuSchedulerStateCalls() []struct {
	GpuInstance        nvml.GpuInstance
	VgpuSchedulerState *nvml.VgpuSchedulerState
} {
	var calls []struct {
		GpuInstance        nvml.GpuInstance
		VgpuSchedulerState *nvml.VgpuSchedulerState
	}
	mock.lockGpuInstanceSetVgpuSchedulerState.RLock()
	calls = mock.calls.GpuInstanceSetVgpuSchedulerState
	mock.lockGpuInstanceSetVgpuSchedulerState.RUnlock()
	return calls
}

// Init calls InitFunc.
func (mock *Interface) Init() nvml.Return {
	if mock.InitFunc == nil {
		panic("Interface.InitFunc: method is nil but Interface.Init was just called")
	}
	callInfo := struct {
	}{}
	mock.lockInit.Lock()
	mock.calls.Init = append(mock.calls.Init, callInfo)
	mock.lockInit.Unlock()
	return mock.InitFunc()
}

// InitCalls gets all the calls that were made to Init.
// Check the length with:
//
//	len(mockedInterface.InitCalls())
func (mock *Interface) InitCalls() []struct {
} {
	var calls []struct {
	}
	mock.lockInit.RLock()
	calls = mock.calls.Init
	mock.lockInit.RUnlock()
	return calls
}

// InitWithFlags calls InitWithFlagsFunc.
func (mock *Interface) InitWithFlags(v uint32) nvml.Return {
	if mock.InitWithFlagsFunc == nil {
		panic("Interface.InitWithFlagsFunc: method is nil but Interface.InitWithFlags was just called")
	}
	callInfo := struct {
		V uint32
	}{
		V: v,
	}
	mock.lockInitWithFlags.Lock()
	mock.calls.InitWithFlags = append(mock.calls.InitWithFlags, callInfo)
	mock.lockInitWithFlags.Unlock()
	return mock.InitWithFlagsFunc(v)
}

// InitWithFlagsCalls gets all the calls that were made to InitWithFlags.
// Check the length with:
//
//	len(mockedInterface.InitWithFlagsCalls())
func (mock *Interface) InitWithFlagsCalls() []struct {
	V uint32
} {
	var calls []struct {
		V uint32
	}
	mock.lockInitWithFlags.RLock()
	calls = mock.calls.InitWithFlags
	mock.lockInitWithFlags.RUnlock()
	return calls
}

// SetVgpuVersion calls SetVgpuVersionFunc.
func (mock *Interface) SetVgpuVersion(vgpuVersion *nvml.VgpuVersion) nvml.Return {
	if mock.SetVgpuVersionFunc == nil {
		panic("Interface.SetVgpuVersionFunc: method is nil but Interface.SetVgpuVersion was just called")
	}
	callInfo := struct {
		VgpuVersion *nvml.VgpuVersion
	}{
		VgpuVersion: vgpuVersion,
	}
	mock.lockSetVgpuVersion.Lock()
	mock.calls.SetVgpuVersion = append(mock.calls.SetVgpuVersion, callInfo)
	mock.lockSetVgpuVersion.Unlock()
	return mock.SetVgpuVersionFunc(vgpuVersion)
}

// SetVgpuVersionCalls gets all the calls that were made to SetVgpuVersion.
// Check the length with:
//
//	len(mockedInterface.SetVgpuVersionCalls())
func (mock *Interface) SetVgpuVersionCalls() []struct {
	VgpuVersion *nvml.VgpuVersion
} {
	var calls []struct {
		VgpuVersion *nvml.VgpuVersion
	}
	mock.lockSetVgpuVersion.RLock()
	calls = mock.calls.SetVgpuVersion
	mock.lockSetVgpuVersion.RUnlock()
	return calls
}

// Shutdown calls ShutdownFunc.
func (mock *Interface) Shutdown() nvml.Return {
	if mock.ShutdownFunc == nil {
		panic("Interface.ShutdownFunc: method is nil but Interface.Shutdown was just called")
	}
	callInfo := struct {
	}{}
	mock.lockShutdown.Lock()
	mock.calls.Shutdown = append(mock.calls.Shutdown, callInfo)
	mock.lockShutdown.Unlock()
	return mock.ShutdownFunc()
}

// ShutdownCalls gets all the calls that were made to Shutdown.
// Check the length with:
//
//	len(mockedInterface.ShutdownCalls())
func (mock *Interface) ShutdownCalls() []struct {
} {
	var calls []struct {
	}
	mock.lockShutdown.RLock()
	calls = mock.calls.Shutdown
	mock.lockShutdown.RUnlock()
	return calls
}

// SystemEventSetCreate calls SystemEventSetCreateFunc.
func (mock *Interface) SystemEventSetCreate(systemEventSetCreateRequest *nvml.SystemEventSetCreateRequest) nvml.Return {
	if mock.SystemEventSetCreateFunc == nil {
		panic("Interface.SystemEventSetCreateFunc: method is nil but Interface.SystemEventSetCreate was just called")
	}
	callInfo := struct {
		SystemEventSetCreateRequest *nvml.SystemEventSetCreateRequest
	}{
		SystemEventSetCreateRequest: systemEventSetCreateRequest,
	}
	mock.lockSystemEventSetCreate.Lock()
	mock.calls.SystemEventSetCreate = append(mock.calls.SystemEventSetCreate, callInfo)
	mock.lockSystemEventSetCreate.Unlock()
	return mock.SystemEventSetCreateFunc(systemEventSetCreateRequest)
}

// SystemEventSetCreateCalls gets all the calls that were made to SystemEventSetCreate.
// Check the length with:
//
//	len(mockedInterface.SystemEventSetCreateCalls())
func (mock *Interface) SystemEventSetCreateCalls() []struct {
	SystemEventSetCreateRequest *nvml.SystemEventSetCreateRequest
} {
	var calls []struct {
		SystemEventSetCreateRequest *nvml.SystemEventSetCreateRequest
	}
	mock.lockSystemEventSetCreate.RLock()
	calls = mock.calls.SystemEventSetCreate
	mock.lockSystemEventSetCreate.RUnlock()
	return calls
}

// SystemEventSetFree calls SystemEventSetFreeFunc.
func (mock *Interface) SystemEventSetFree(systemEventSetFreeRequest *nvml.SystemEventSetFreeRequest) nvml.Return {
	if mock.SystemEventSetFreeFunc == nil {
		panic("Interface.SystemEventSetFreeFunc: method is nil but Interface.SystemEventSetFree was just called")
	}
	callInfo := struct {
		SystemEventSetFreeRequest *nvml.SystemEventSetFreeRequest
	}{
		SystemEventSetFreeRequest: systemEventSetFreeRequest,
	}
	mock.lockSystemEventSetFree.Lock()
	mock.calls.SystemEventSetFree = append(mock.calls.SystemEventSetFree, callInfo)
	mock.lockSystemEventSetFree.Unlock()
	return mock.SystemEventSetFreeFunc(systemEventSetFreeRequest)
}

// SystemEventSetFreeCalls gets all the calls that were made to SystemEventSetFree.
// Check the length with:
//
//	len(mockedInterface.SystemEventSetFreeCalls())
func (mock *Interface) SystemEventSetFreeCalls() []struct {
	SystemEventSetFreeRequest *nvml.SystemEventSetFreeRequest
} {
	var calls []struct {
		SystemEventSetFreeRequest *nvml.SystemEventSetFreeRequest
	}
	mock.lockSystemEventSetFree.RLock()
	calls = mock.calls.SystemEventSetFree
	mock.lockSystemEventSetFree.RUnlock()
	return calls
}

// SystemEventSetWait calls SystemEventSetWaitFunc.
func (mock *Interface) SystemEventSetWait(systemEventSetWaitRequest *nvml.SystemEventSetWaitRequest) nvml.Return {
	if mock.SystemEventSetWaitFunc == nil {
		panic("Interface.SystemEventSetWaitFunc: method is nil but Interface.SystemEventSetWait was just called")
	}
	callInfo := struct {
		SystemEventSetWaitRequest *nvml.SystemEventSetWaitRequest
	}{
		SystemEventSetWaitRequest: systemEventSetWaitRequest,
	}
	mock.lockSystemEventSetWait.Lock()
	mock.calls.SystemEventSetWait = append(mock.calls.SystemEventSetWait, callInfo)
	mock.lockSystemEventSetWait.Unlock()
	return mock.SystemEventSetWaitFunc(systemEventSetWaitRequest)
}

// SystemEventSetWaitCalls gets all the calls that were made to SystemEventSetWait.
// Check the length with:
//
//	len(mockedInterface.SystemEventSetWaitCalls())
func (mock *Interface) SystemEventSetWaitCalls() []struct {
	SystemEventSetWaitRequest *nvml.SystemEventSetWaitRequest
} {
	var calls []struct {
		SystemEventSetWaitRequest *nvml.SystemEventSetWaitRequest
	}
	mock.lockSystemEventSetWait.RLock()
	calls = mock.calls.SystemEventSetWait
	mock.lockSystemEventSetWait.RUnlock()
	return calls
}

// SystemGetConfComputeCapabilities calls SystemGetConfComputeCapabilitiesFunc.
func (mock *Interface) SystemGetConfComputeCapabilities() (nvml.ConfComputeSystemCaps, nvml.Return) {
	if mock.SystemGetConfComputeCapabilitiesFunc == nil {
		panic("Interface.SystemGetConfComputeCapabilitiesFunc: method is nil but Interface.SystemGetConfComputeCapabilities was just called")
	}
	callInfo := struct {
	}{}
	mock.lockSystemGetConfComputeCapabilities.Lock()
	mock.calls.SystemGetConfComputeCapabilities = append(mock.calls.SystemGetConfComputeCapabilities, callInfo)
	mock.lockSystemGetConfComputeCapabilities.Unlock()
	return mock.SystemGetConfComputeCapabilitiesFunc()
}

// SystemGetConfComputeCapabilitiesCalls gets all the calls that were made to SystemGetConfComputeCapabilities.
// Check the length with:
//
//	len(mockedInterface.SystemGetConfComputeCapabilitiesCalls())
func (mock *Interface) SystemGetConfComputeCapabilitiesCalls() []struct {
} {
	var calls []struct {
	}
	mock.lockSystemGetConfComputeCapabilities.RLock()
	calls = mock.calls.SystemGetConfComputeCapabilities
	mock.lockSystemGetConfComputeCapabilities.RUnlock()
	return calls
}

// SystemGetConfComputeGpusReadyState calls SystemGetConfComputeGpusReadyStateFunc.
func (mock *Interface) SystemGetConfComputeGpusReadyState() (uint32, nvml.Return) {
	if mock.SystemGetConfComputeGpusReadyStateFunc == nil {
		panic("Interface.SystemGetConfComputeGpusReadyStateFunc: method is nil but Interface.SystemGetConfComputeGpusReadyState was just called")
	}
	callInfo := struct {
	}{}
	mock.lockSystemGetConfComputeGpusReadyState.Lock()
	mock.calls.SystemGetConfComputeGpusReadyState = append(mock.calls.SystemGetConfComputeGpusReadyState, callInfo)
	mock.lockSystemGetConfComputeGpusReadyState.Unlock()
	return mock.SystemGetConfComputeGpusReadyStateFunc()
}

// SystemGetConfComputeGpusReadyStateCalls gets all the calls that were made to SystemGetConfComputeGpusReadyState.
// Check the length with:
//
//	len(mockedInterface.SystemGetConfComputeGpusReadyStateCalls())
func (mock *Interface) SystemGetConfComputeGpusReadyStateCalls() []struct {
} {
	var calls []struct {
	}
	mock.lockSystemGetConfComputeGpusReadyState.RLock()
	calls = mock.calls.SystemGetConfComputeGpusReadyState
	mock.lockSystemGetConfComputeGpusReadyState.RUnlock()
	return calls
}

// SystemGetConfComputeKeyRotationThresholdInfo calls SystemGetConfComputeKeyRotationThresholdInfoFunc.
func (mock *Interface) SystemGetConfComputeKeyRotationThresholdInfo() (nvml.ConfComputeGetKeyRotationThresholdInfo, nvml.Return) {
	if mock.SystemGetConfComputeKeyRotationThresholdInfoFunc == nil {
		panic("Interface.SystemGetConfComputeKeyRotationThresholdInfoFunc: method is nil but Interface.SystemGetConfComputeKeyRotationThresholdInfo was just called")
	}
	callInfo := struct {
	}{}
	mock.lockSystemGetConfComputeKeyRotationThresholdInfo.Lock()
	mock.calls.SystemGetConfComputeKeyRotationThresholdInfo = append(mock.calls.SystemGetConfComputeKeyRotationThresholdInfo, callInfo)
	mock.lockSystemGetConfComputeKeyRotationThresholdInfo.Unlock()
	return mock.SystemGetConfComputeKeyRotationThresholdInfoFunc()
}

// SystemGetConfComputeKeyRotationThresholdInfoCalls gets all the calls that were made to SystemGetConfComputeKeyRotationThresholdInfo.
// Check the length with:
//
//	len(mockedInterface.SystemGetConfComputeKeyRotationThresholdInfoCalls())
func (mock *Interface) SystemGetConfComputeKeyRotationThresholdInfoCalls() []struct {
} {
	var calls []struct {
	}
	mock.lockSystemGetConfComputeKeyRotationThresholdInfo.RLock()
	calls = mock.calls.SystemGetConfComputeKeyRotationThresholdInfo
	mock.lockSystemGetConfComputeKeyRotationThresholdInfo.RUnlock()
	return calls
}

// SystemGetConfComputeSettings calls SystemGetConfComputeSettingsFunc.
func (mock *Interface) SystemGetConfComputeSettings() (nvml.SystemConfComputeSettings, nvml.Return) {
	if mock.SystemGetConfComputeSettingsFunc == nil {
		panic("Interface.SystemGetConfComputeSettingsFunc: method is nil but Interface.SystemGetConfComputeSettings was just called")
	}
	callInfo := struct {
	}{}
	mock.lockSystemGetConfComputeSettings.Lock()
	mock.calls.SystemGetConfComputeSettings = append(mock.calls.SystemGetConfComputeSettings, callInfo)
	mock.lockSystemGetConfComputeSettings.Unlock()
	return mock.SystemGetConfComputeSettingsFunc()
}

// SystemGetConfComputeSettingsCalls gets all the calls that were made to SystemGetConfComputeSettings.
// Check the length with:
//
//	len(mockedInterface.SystemGetConfComputeSettingsCalls())
func (mock *Interface) SystemGetConfComputeSettingsCalls() []struct {
} {
	var calls []struct {
	}
	mock.lockSystemGetConfComputeSettings.RLock()
	calls = mock.calls.SystemGetConfComputeSettings
	mock.lockSystemGetConfComputeSettings.RUnlock()
	return calls
}

// SystemGetConfComputeState calls SystemGetConfComputeStateFunc.
func (mock *Interface) SystemGetConfComputeState() (nvml.ConfComputeSystemState, nvml.Return) {
	if mock.SystemGetConfComputeStateFunc == nil {
		panic("Interface.SystemGetConfComputeStateFunc: method is nil but Interface.SystemGetConfComputeState was just called")
	}
	callInfo := struct {
	}{}
	mock.lockSystemGetConfComputeState.Lock()
	mock.calls.SystemGetConfComputeState = append(mock.calls.SystemGetConfComputeState, callInfo)
	mock.lockSystemGetConfComputeState.Unlock()
	return mock.SystemGetConfComputeStateFunc()
}

// SystemGetConfComputeStateCalls gets all the calls that were made to SystemGetConfComputeState.
// Check the length with:
//
//	len(mockedInterface.SystemGetConfComputeStateCalls())
func (mock *Interface) SystemGetConfComputeStateCalls() []struct {
} {
	var calls []struct {
	}
	mock.lockSystemGetConfComputeState.RLock()
	calls = mock.calls.SystemGetConfComputeState
	mock.lockSystemGetConfComputeState.RUnlock()
	return calls
}

// SystemGetCudaDriverVersion calls SystemGetCudaDriverVersionFunc.
func (mock *Interface) SystemGetCudaDriverVersion() (int, nvml.Return) {
	if mock.SystemGetCudaDriverVersionFunc == nil {
		panic("Interface.SystemGetCudaDriverVersionFunc: method is nil but Interface.SystemGetCudaDriverVersion was just called")
	}
	callInfo := struct {
	}{}
	mock.lockSystemGetCudaDriverVersion.Lock()
	mock.calls.SystemGetCudaDriverVersion = append(mock.calls.SystemGetCudaDriverVersion, callInfo)
	mock.lockSystemGetCudaDriverVersion.Unlock()
	return mock.SystemGetCudaDriverVersionFunc()
}

// SystemGetCudaDriverVersionCalls gets all the calls that were made to SystemGetCudaDriverVersion.
// Check the length with:
//
//	len(mockedInterface.SystemGetCudaDriverVersionCalls())
func (mock *Interface) SystemGetCudaDriverVersionCalls() []struct {
} {
	var calls []struct {
	}
	mock.lockSystemGetCudaDriverVersion.RLock()
	calls = mock.calls.SystemGetCudaDriverVersion
	mock.lockSystemGetCudaDriverVersion.RUnlock()
	return calls
}

// SystemGetCudaDriverVersion_v2 calls SystemGetCudaDriverVersion_v2Func.
func (mock *Interface) SystemGetCudaDriverVersion_v2() (int, nvml.Return) {
	if mock.SystemGetCudaDriverVersion_v2Func == nil {
		panic("Interface.SystemGetCudaDriverVersion_v2Func: method is nil but Interface.SystemGetCudaDriverVersion_v2 was just called")
	}
	callInfo := struct {
	}{}
	mock.lockSystemGetCudaDriverVersion_v2.Lock()
	mock.calls.SystemGetCudaDriverVersion_v2 = append(mock.calls.SystemGetCudaDriverVersion_v2, callInfo)
	mock.lockSystemGetCudaDriverVersion_v2.Unlock()
	return mock.SystemGetCudaDriverVersion_v2Func()
}

// SystemGetCudaDriverVersion_v2Calls gets all the calls that were made to SystemGetCudaDriverVersion_v2.
// Check the length with:
//
//	len(mockedInterface.SystemGetCudaDriverVersion_v2Calls())
func (mock *Interface) SystemGetCudaDriverVersion_v2Calls() []struct {
} {
	var calls []struct {
	}
	mock.lockSystemGetCudaDriverVersion_v2.RLock()
	calls = mock.calls.SystemGetCudaDriverVersion_v2
	mock.lockSystemGetCudaDriverVersion_v2.RUnlock()
	return calls
}

// SystemGetDriverBranch calls SystemGetDriverBranchFunc.
func (mock *Interface) SystemGetDriverBranch() (nvml.SystemDriverBranchInfo, nvml.Return) {
	if mock.SystemGetDriverBranchFunc == nil {
		panic("Interface.SystemGetDriverBranchFunc: method is nil but Interface.SystemGetDriverBranch was just called")
	}
	callInfo := struct {
	}{}
	mock.lockSystemGetDriverBranch.Lock()
	mock.calls.SystemGetDriverBranch = append(mock.calls.SystemGetDriverBranch, callInfo)
	mock.lockSystemGetDriverBranch.Unlock()
	return mock.SystemGetDriverBranchFunc()
}

// SystemGetDriverBranchCalls gets all the calls that were made to SystemGetDriverBranch.
// Check the length with:
//
//	len(mockedInterface.SystemGetDriverBranchCalls())
func (mock *Interface) SystemGetDriverBranchCalls() []struct {
} {
	var calls []struct {
	}
	mock.lockSystemGetDriverBranch.RLock()
	calls = mock.calls.SystemGetDriverBranch
	mock.lockSystemGetDriverBranch.RUnlock()
	return calls
}

// SystemGetDriverVersion calls SystemGetDriverVersionFunc.
func (mock *Interface) SystemGetDriverVersion() (string, nvml.Return) {
	if mock.SystemGetDriverVersionFunc == nil {
		panic("Interface.SystemGetDriverVersionFunc: method is nil but Interface.SystemGetDriverVersion was just called")
	}
	callInfo := struct {
	}{}
	mock.lockSystemGetDriverVersion.Lock()
	mock.calls.SystemGetDriverVersion = append(mock.calls.SystemGetDriverVersion, callInfo)
	mock.lockSystemGetDriverVersion.Unlock()
	return mock.SystemGetDriverVersionFunc()
}

// SystemGetDriverVersionCalls gets all the calls that were made to SystemGetDriverVersion.
// Check the length with:
//
//	len(mockedInterface.SystemGetDriverVersionCalls())
func (mock *Interface) SystemGetDriverVersionCalls() []struct {
} {
	var calls []struct {
	}
	mock.lockSystemGetDriverVersion.RLock()
	calls = mock.calls.SystemGetDriverVersion
	mock.lockSystemGetDriverVersion.RUnlock()
	return calls
}

// SystemGetHicVersion calls SystemGetHicVersionFunc.
func (mock *Interface) SystemGetHicVersion() ([]nvml.HwbcEntry, nvml.Return) {
	if mock.SystemGetHicVersionFunc == nil {
		panic("Interface.SystemGetHicVersionFunc: method is nil but Interface.SystemGetHicVersion was just called")
	}
	callInfo := struct {
	}{}
	mock.lockSystemGetHicVersion.Lock()
	mock.calls.SystemGetHicVersion = append(mock.calls.SystemGetHicVersion, callInfo)
	mock.lockSystemGetHicVersion.Unlock()
	return mock.SystemGetHicVersionFunc()
}

// SystemGetHicVersionCalls gets all the calls that were made to SystemGetHicVersion.
// Check the length with:
//
//	len(mockedInterface.SystemGetHicVersionCalls())
func (mock *Interface) SystemGetHicVersionCalls() []struct {
} {
	var calls []struct {
	}
	mock.lockSystemGetHicVersion.RLock()
	calls = mock.calls.SystemGetHicVersion
	mock.lockSystemGetHicVersion.RUnlock()
	return calls
}

// SystemGetNVMLVersion calls SystemGetNVMLVersionFunc.
func (mock *Interface) SystemGetNVMLVersion() (string, nvml.Return) {
	if mock.SystemGetNVMLVersionFunc == nil {
		panic("Interface.SystemGetNVMLVersionFunc: method is nil but Interface.SystemGetNVMLVersion was just called")
	}
	callInfo := struct {
	}{}
	mock.lockSystemGetNVMLVersion.Lock()
	mock.calls.SystemGetNVMLVersion = append(mock.calls.SystemGetNVMLVersion, callInfo)
	mock.lockSystemGetNVMLVersion.Unlock()
	return mock.SystemGetNVMLVersionFunc()
}

// SystemGetNVMLVersionCalls gets all the calls that were made to SystemGetNVMLVersion.
// Check the length with:
//
//	len(mockedInterface.SystemGetNVMLVersionCalls())
func (mock *Interface) SystemGetNVMLVersionCalls() []struct {
} {
	var calls []struct {
	}
	mock.lockSystemGetNVMLVersion.RLock()
	calls = mock.calls.SystemGetNVMLVersion
	mock.lockSystemGetNVMLVersion.RUnlock()
	return calls
}

// SystemGetNvlinkBwMode calls SystemGetNvlinkBwModeFunc.
func (mock *Interface) SystemGetNvlinkBwMode() (uint32, nvml.Return) {
	if mock.SystemGetNvlinkBwModeFunc == nil {
		panic("Interface.SystemGetNvlinkBwModeFunc: method is nil but Interface.SystemGetNvlinkBwMode was just called")
	}
	callInfo := struct {
	}{}
	mock.lockSystemGetNvlinkBwMode.Lock()
	mock.calls.SystemGetNvlinkBwMode = append(mock.calls.SystemGetNvlinkBwMode, callInfo)
	mock.lockSystemGetNvlinkBwMode.Unlock()
	return mock.SystemGetNvlinkBwModeFunc()
}

// SystemGetNvlinkBwModeCalls gets all the calls that were made to SystemGetNvlinkBwMode.
// Check the length with:
//
//	len(mockedInterface.SystemGetNvlinkBwModeCalls())
func (mock *Interface) SystemGetNvlinkBwModeCalls() []struct {
} {
	var calls []struct {
	}
	mock.lockSystemGetNvlinkBwMode.RLock()
	calls = mock.calls.SystemGetNvlinkBwMode
	mock.lockSystemGetNvlinkBwMode.RUnlock()
	return calls
}

// SystemGetProcessName calls SystemGetProcessNameFunc.
func (mock *Interface) SystemGetProcessName(n int) (string, nvml.Return) {
	if mock.SystemGetProcessNameFunc == nil {
		panic("Interface.SystemGetProcessNameFunc: method is nil but Interface.SystemGetProcessName was just called")
	}
	callInfo := struct {
		N int
	}{
		N: n,
	}
	mock.lockSystemGetProcessName.Lock()
	mock.calls.SystemGetProcessName = append(mock.calls.SystemGetProcessName, callInfo)
	mock.lockSystemGetProcessName.Unlock()
	return mock.SystemGetProcessNameFunc(n)
}

// SystemGetProcessNameCalls gets all the calls that were made to SystemGetProcessName.
// Check the length with:
//
//	len(mockedInterface.SystemGetProcessNameCalls())
func (mock *Interface) SystemGetProcessNameCalls() []struct {
	N int
} {
	var calls []struct {
		N int
	}
	mock.lockSystemGetProcessName.RLock()
	calls = mock.calls.SystemGetProcessName
	mock.lockSystemGetProcessName.RUnlock()
	return calls
}

// SystemGetTopologyGpuSet calls SystemGetTopologyGpuSetFunc.
func (mock *Interface) SystemGetTopologyGpuSet(n int) ([]nvml.Device, nvml.Return) {
	if mock.SystemGetTopologyGpuSetFunc == nil {
		panic("Interface.SystemGetTopologyGpuSetFunc: method is nil but Interface.SystemGetTopologyGpuSet was just called")
	}
	callInfo := struct {
		N int
	}{
		N: n,
	}
	mock.lockSystemGetTopologyGpuSet.Lock()
	mock.calls.SystemGetTopologyGpuSet = append(mock.calls.SystemGetTopologyGpuSet, callInfo)
	mock.lockSystemGetTopologyGpuSet.Unlock()
	return mock.SystemGetTopologyGpuSetFunc(n)
}

// SystemGetTopologyGpuSetCalls gets all the calls that were made to SystemGetTopologyGpuSet.
// Check the length with:
//
//	len(mockedInterface.SystemGetTopologyGpuSetCalls())
func (mock *Interface) SystemGetTopologyGpuSetCalls() []struct {
	N int
} {
	var calls []struct {
		N int
	}
	mock.lockSystemGetTopologyGpuSet.RLock()
	calls = mock.calls.SystemGetTopologyGpuSet
	mock.lockSystemGetTopologyGpuSet.RUnlock()
	return calls
}

// SystemRegisterEvents calls SystemRegisterEventsFunc.
func (mock *Interface) SystemRegisterEvents(systemRegisterEventRequest *nvml.SystemRegisterEventRequest) nvml.Return {
	if mock.SystemRegisterEventsFunc == nil {
		panic("Interface.SystemRegisterEventsFunc: method is nil but Interface.SystemRegisterEvents was just called")
	}
	callInfo := struct {
		SystemRegisterEventRequest *nvml.SystemRegisterEventRequest
	}{
		SystemRegisterEventRequest: systemRegisterEventRequest,
	}
	mock.lockSystemRegisterEvents.Lock()
	mock.calls.SystemRegisterEvents = append(mock.calls.SystemRegisterEvents, callInfo)
	mock.lockSystemRegisterEvents.Unlock()
	return mock.SystemRegisterEventsFunc(systemRegisterEventRequest)
}

// SystemRegisterEventsCalls gets all the calls that were made to SystemRegisterEvents.
// Check the length with:
//
//	len(mockedInterface.SystemRegisterEventsCalls())
func (mock *Interface) SystemRegisterEventsCalls() []struct {
	SystemRegisterEventRequest *nvml.SystemRegisterEventRequest
} {
	var calls []struct {
		SystemRegisterEventRequest *nvml.SystemRegisterEventRequest
	}
	mock.lockSystemRegisterEvents.RLock()
	calls = mock.calls.SystemRegisterEvents
	mock.lockSystemRegisterEvents.RUnlock()
	return calls
}

// SystemSetConfComputeGpusReadyState calls SystemSetConfComputeGpusReadyStateFunc.
func (mock *Interface) SystemSetConfComputeGpusReadyState(v uint32) nvml.Return {
	if mock.SystemSetConfComputeGpusReadyStateFunc == nil {
		panic("Interface.SystemSetConfComputeGpusReadyStateFunc: method is nil but Interface.SystemSetConfComputeGpusReadyState was just called")
	}
	callInfo := struct {
		V uint32
	}{
		V: v,
	}
	mock.lockSystemSetConfComputeGpusReadyState.Lock()
	mock.calls.SystemSetConfComputeGpusReadyState = append(mock.calls.SystemSetConfComputeGpusReadyState, callInfo)
	mock.lockSystemSetConfComputeGpusReadyState.Unlock()
	return mock.SystemSetConfComputeGpusReadyStateFunc(v)
}

// SystemSetConfComputeGpusReadyStateCalls gets all the calls that were made to SystemSetConfComputeGpusReadyState.
// Check the length with:
//
//	len(mockedInterface.SystemSetConfComputeGpusReadyStateCalls())
func (mock *Interface) SystemSetConfComputeGpusReadyStateCalls() []struct {
	V uint32
} {
	var calls []struct {
		V uint32
	}
	mock.lockSystemSetConfComputeGpusReadyState.RLock()
	calls = mock.calls.SystemSetConfComputeGpusReadyState
	mock.lockSystemSetConfComputeGpusReadyState.RUnlock()
	return calls
}

// SystemSetConfComputeKeyRotationThresholdInfo calls SystemSetConfComputeKeyRotationThresholdInfoFunc.
func (mock *Interface) SystemSetConfComputeKeyRotationThresholdInfo(confComputeSetKeyRotationThresholdInfo nvml.ConfComputeSetKeyRotationThresholdInfo) nvml.Return {
	if mock.SystemSetConfComputeKeyRotationThresholdInfoFunc == nil {
		panic("Interface.SystemSetConfComputeKeyRotationThresholdInfoFunc: method is nil but Interface.SystemSetConfComputeKeyRotationThresholdInfo was just called")
	}
	callInfo := struct {
		ConfComputeSetKeyRotationThresholdInfo nvml.ConfComputeSetKeyRotationThresholdInfo
	}{
		ConfComputeSetKeyRotationThresholdInfo: confComputeSetKeyRotationThresholdInfo,
	}
	mock.lockSystemSetConfComputeKeyRotationThresholdInfo.Lock()
	mock.calls.SystemSetConfComputeKeyRotationThresholdInfo = append(mock.calls.SystemSetConfComputeKeyRotationThresholdInfo, callInfo)
	mock.lockSystemSetConfComputeKeyRotationThresholdInfo.Unlock()
	return mock.SystemSetConfComputeKeyRotationThresholdInfoFunc(confComputeSetKeyRotationThresholdInfo)
}

// SystemSetConfComputeKeyRotationThresholdInfoCalls gets all the calls that were made to SystemSetConfComputeKeyRotationThresholdInfo.
// Check the length with:
//
//	len(mockedInterface.SystemSetConfComputeKeyRotationThresholdInfoCalls())
func (mock *Interface) SystemSetConfComputeKeyRotationThresholdInfoCalls() []struct {
	ConfComputeSetKeyRotationThresholdInfo nvml.ConfComputeSetKeyRotationThresholdInfo
} {
	var calls []struct {
		ConfComputeSetKeyRotationThresholdInfo nvml.ConfComputeSetKeyRotationThresholdInfo
	}
	mock.lockSystemSetConfComputeKeyRotationThresholdInfo.RLock()
	calls = mock.calls.SystemSetConfComputeKeyRotationThresholdInfo
	mock.lockSystemSetConfComputeKeyRotationThresholdInfo.RUnlock()
	return calls
}

// SystemSetNvlinkBwMode calls SystemSetNvlinkBwModeFunc.
func (mock *Interface) SystemSetNvlinkBwMode(v uint32) nvml.Return {
	if mock.SystemSetNvlinkBwModeFunc == nil {
		panic("Interface.SystemSetNvlinkBwModeFunc: method is nil but Interface.SystemSetNvlinkBwMode was just called")
	}
	callInfo := struct {
		V uint32
	}{
		V: v,
	}
	mock.lockSystemSetNvlinkBwMode.Lock()
	mock.calls.SystemSetNvlinkBwMode = append(mock.calls.SystemSetNvlinkBwMode, callInfo)
	mock.lockSystemSetNvlinkBwMode.Unlock()
	return mock.SystemSetNvlinkBwModeFunc(v)
}

// SystemSetNvlinkBwModeCalls gets all the calls that were made to SystemSetNvlinkBwMode.
// Check the length with:
//
//	len(mockedInterface.SystemSetNvlinkBwModeCalls())
func (mock *Interface) SystemSetNvlinkBwModeCalls() []struct {
	V uint32
} {
	var calls []struct {
		V uint32
	}
	mock.lockSystemSetNvlinkBwMode.RLock()
	calls = mock.calls.SystemSetNvlinkBwMode
	mock.lockSystemSetNvlinkBwMode.RUnlock()
	return calls
}

// UnitGetCount calls UnitGetCountFunc.
func (mock *Interface) UnitGetCount() (int, nvml.Return) {
	if mock.UnitGetCountFunc == nil {
		panic("Interface.UnitGetCountFunc: method is nil but Interface.UnitGetCount was just called")
	}
	callInfo := struct {
	}{}
	mock.lockUnitGetCount.Lock()
	mock.calls.UnitGetCount = append(mock.calls.UnitGetCount, callInfo)
	mock.lockUnitGetCount.Unlock()
	return mock.UnitGetCountFunc()
}

// UnitGetCountCalls gets all the calls that were made to UnitGetCount.
// Check the length with:
//
//	len(mockedInterface.UnitGetCountCalls())
func (mock *Interface) UnitGetCountCalls() []struct {
} {
	var calls []struct {
	}
	mock.lockUnitGetCount.RLock()
	calls = mock.calls.UnitGetCount
	mock.lockUnitGetCount.RUnlock()
	return calls
}

// UnitGetDevices calls UnitGetDevicesFunc.
func (mock *Interface) UnitGetDevices(unit nvml.Unit) ([]nvml.Device, nvml.Return) {
	if mock.UnitGetDevicesFunc == nil {
		panic("Interface.UnitGetDevicesFunc: method is nil but Interface.UnitGetDevices was just called")
	}
	callInfo := struct {
		Unit nvml.Unit
	}{
		Unit: unit,
	}
	mock.lockUnitGetDevices.Lock()
	mock.calls.UnitGetDevices = append(mock.calls.UnitGetDevices, callInfo)
	mock.lockUnitGetDevices.Unlock()
	return mock.UnitGetDevicesFunc(unit)
}

// UnitGetDevicesCalls gets all the calls that were made to UnitGetDevices.
// Check the length with:
//
//	len(mockedInterface.UnitGetDevicesCalls())
func (mock *Interface) UnitGetDevicesCalls() []struct {
	Unit nvml.Unit
} {
	var calls []struct {
		Unit nvml.Unit
	}
	mock.lockUnitGetDevices.RLock()
	calls = mock.calls.UnitGetDevices
	mock.lockUnitGetDevices.RUnlock()
	return calls
}

// UnitGetFanSpeedInfo calls UnitGetFanSpeedInfoFunc.
func (mock *Interface) UnitGetFanSpeedInfo(unit nvml.Unit) (nvml.UnitFanSpeeds, nvml.Return) {
	if mock.UnitGetFanSpeedInfoFunc == nil {
		panic("Interface.UnitGetFanSpeedInfoFunc: method is nil but Interface.UnitGetFanSpeedInfo was just called")
	}
	callInfo := struct {
		Unit nvml.Unit
	}{
		Unit: unit,
	}
	mock.lockUnitGetFanSpeedInfo.Lock()
	mock.calls.UnitGetFanSpeedInfo = append(mock.calls.UnitGetFanSpeedInfo, callInfo)
	mock.lockUnitGetFanSpeedInfo.Unlock()
	return mock.UnitGetFanSpeedInfoFunc(unit)
}

// UnitGetFanSpeedInfoCalls gets all the calls that were made to UnitGetFanSpeedInfo.
// Check the length with:
//
//	len(mockedInterface.UnitGetFanSpeedInfoCalls())
func (mock *Interface) UnitGetFanSpeedInfoCalls() []struct {
	Unit nvml.Unit
} {
	var calls []struct {
		Unit nvml.Unit
	}
	mock.lockUnitGetFanSpeedInfo.RLock()
	calls = mock.calls.UnitGetFanSpeedInfo
	mock.lockUnitGetFanSpeedInfo.RUnlock()
	return calls
}

// UnitGetHandleByIndex calls UnitGetHandleByIndexFunc.
func (mock *Interface) UnitGetHandleByIndex(n int) (nvml.Unit, nvml.Return) {
	if mock.UnitGetHandleByIndexFunc == nil {
		panic("Interface.UnitGetHandleByIndexFunc: method is nil but Interface.UnitGetHandleByIndex was just called")
	}
	callInfo := struct {
		N int
	}{
		N: n,
	}
	mock.lockUnitGetHandleByIndex.Lock()
	mock.calls.UnitGetHandleByIndex = append(mock.calls.UnitGetHandleByIndex, callInfo)
	mock.lockUnitGetHandleByIndex.Unlock()
	return mock.UnitGetHandleByIndexFunc(n)
}

// UnitGetHandleByIndexCalls gets all the calls that were made to UnitGetHandleByIndex.
// Check the length with:
//
//	len(mockedInterface.UnitGetHandleByIndexCalls())
func (mock *Interface) UnitGetHandleByIndexCalls() []struct {
	N int
} {
	var calls []struct {
		N int
	}
	mock.lockUnitGetHandleByIndex.RLock()
	calls = mock.calls.UnitGetHandleByIndex
	mock.lockUnitGetHandleByIndex.RUnlock()
	return calls
}

// UnitGetLedState calls UnitGetLedStateFunc.
func (mock *Interface) UnitGetLedState(unit nvml.Unit) (nvml.LedState, nvml.Return) {
	if mock.UnitGetLedStateFunc == nil {
		panic("Interface.UnitGetLedStateFunc: method is nil but Interface.UnitGetLedState was just called")
	}
	callInfo := struct {
		Unit nvml.Unit
	}{
		Unit: unit,
	}
	mock.lockUnitGetLedState.Lock()
	mock.calls.UnitGetLedState = append(mock.calls.UnitGetLedState, callInfo)
	mock.lockUnitGetLedState.Unlock()
	return mock.UnitGetLedStateFunc(unit)
}

// UnitGetLedStateCalls gets all the calls that were made to UnitGetLedState.
// Check the length with:
//
//	len(mockedInterface.UnitGetLedStateCalls())
func (mock *Interface) UnitGetLedStateCalls() []struct {
	Unit nvml.Unit
} {
	var calls []struct {
		Unit nvml.Unit
	}
	mock.lockUnitGetLedState.RLock()
	calls = mock.calls.UnitGetLedState
	mock.lockUnitGetLedState.RUnlock()
	return calls
}

// UnitGetPsuInfo calls UnitGetPsuInfoFunc.
func (mock *Interface) UnitGetPsuInfo(unit nvml.Unit) (nvml.PSUInfo, nvml.Return) {
	if mock.UnitGetPsuInfoFunc == nil {
		panic("Interface.UnitGetPsuInfoFunc: method is nil but Interface.UnitGetPsuInfo was just called")
	}
	callInfo := struct {
		Unit nvml.Unit
	}{
		Unit: unit,
	}
	mock.lockUnitGetPsuInfo.Lock()
	mock.calls.UnitGetPsuInfo = append(mock.calls.UnitGetPsuInfo, callInfo)
	mock.lockUnitGetPsuInfo.Unlock()
	return mock.UnitGetPsuInfoFunc(unit)
}

// UnitGetPsuInfoCalls gets all the calls that were made to UnitGetPsuInfo.
// Check the length with:
//
//	len(mockedInterface.UnitGetPsuInfoCalls())
func (mock *Interface) UnitGetPsuInfoCalls() []struct {
	Unit nvml.Unit
} {
	var calls []struct {
		Unit nvml.Unit
	}
	mock.lockUnitGetPsuInfo.RLock()
	calls = mock.calls.UnitGetPsuInfo
	mock.lockUnitGetPsuInfo.RUnlock()
	return calls
}

// UnitGetTemperature calls UnitGetTemperatureFunc.
func (mock *Interface) UnitGetTemperature(unit nvml.Unit, n int) (uint32, nvml.Return) {
	if mock.UnitGetTemperatureFunc == nil {
		panic("Interface.UnitGetTemperatureFunc: method is nil but Interface.UnitGetTemperature was just called")
	}
	callInfo := struct {
		Unit nvml.Unit
		N    int
	}{
		Unit: unit,
		N:    n,
	}
	mock.lockUnitGetTemperature.Lock()
	mock.calls.UnitGetTemperature = append(mock.calls.UnitGetTemperature, callInfo)
	mock.lockUnitGetTemperature.Unlock()
	return mock.UnitGetTemperatureFunc(unit, n)
}

// UnitGetTemperatureCalls gets all the calls that were made to UnitGetTemperature.
// Check the length with:
//
//	len(mockedInterface.UnitGetTemperatureCalls())
func (mock *Interface) UnitGetTemperatureCalls() []struct {
	Unit nvml.Unit
	N    int
} {
	var calls []struct {
		Unit nvml.Unit
		N    int
	}
	mock.lockUnitGetTemperature.RLock()
	calls = mock.calls.UnitGetTemperature
	mock.lockUnitGetTemperature.RUnlock()
	return calls
}

// UnitGetUnitInfo calls UnitGetUnitInfoFunc.
func (mock *Interface) UnitGetUnitInfo(unit nvml.Unit) (nvml.UnitInfo, nvml.Return) {
	if mock.UnitGetUnitInfoFunc == nil {
		panic("Interface.UnitGetUnitInfoFunc: method is nil but Interface.UnitGetUnitInfo was just called")
	}
	callInfo := struct {
		Unit nvml.Unit
	}{
		Unit: unit,
	}
	mock.lockUnitGetUnitInfo.Lock()
	mock.calls.UnitGetUnitInfo = append(mock.calls.UnitGetUnitInfo, callInfo)
	mock.lockUnitGetUnitInfo.Unlock()
	return mock.UnitGetUnitInfoFunc(unit)
}

// UnitGetUnitInfoCalls gets all the calls that were made to UnitGetUnitInfo.
// Check the length with:
//
//	len(mockedInterface.UnitGetUnitInfoCalls())
func (mock *Interface) UnitGetUnitInfoCalls() []struct {
	Unit nvml.Unit
} {
	var calls []struct {
		Unit nvml.Unit
	}
	mock.lockUnitGetUnitInfo.RLock()
	calls = mock.calls.UnitGetUnitInfo
	mock.lockUnitGetUnitInfo.RUnlock()
	return calls
}

// UnitSetLedState calls UnitSetLedStateFunc.
func (mock *Interface) UnitSetLedState(unit nvml.Unit, ledColor nvml.LedColor) nvml.Return {
	if mock.UnitSetLedStateFunc == nil {
		panic("Interface.UnitSetLedStateFunc: method is nil but Interface.UnitSetLedState was just called")
	}
	callInfo := struct {
		Unit     nvml.Unit
		LedColor nvml.LedColor
	}{
		Unit:     unit,
		LedColor: ledColor,
	}
	mock.lockUnitSetLedState.Lock()
	mock.calls.UnitSetLedState = append(mock.calls.UnitSetLedState, callInfo)
	mock.lockUnitSetLedState.Unlock()
	return mock.UnitSetLedStateFunc(unit, ledColor)
}

// UnitSetLedStateCalls gets all the calls that were made to UnitSetLedState.
// Check the length with:
//
//	len(mockedInterface.UnitSetLedStateCalls())
func (mock *Interface) UnitSetLedStateCalls() []struct {
	Unit     nvml.Unit
	LedColor nvml.LedColor
} {
	var calls []struct {
		Unit     nvml.Unit
		LedColor nvml.LedColor
	}
	mock.lockUnitSetLedState.RLock()
	calls = mock.calls.UnitSetLedState
	mock.lockUnitSetLedState.RUnlock()
	return calls
}

// VgpuInstanceClearAccountingPids calls VgpuInstanceClearAccountingPidsFunc.
func (mock *Interface) VgpuInstanceClearAccountingPids(vgpuInstance nvml.VgpuInstance) nvml.Return {
	if mock.VgpuInstanceClearAccountingPidsFunc == nil {
		panic("Interface.VgpuInstanceClearAccountingPidsFunc: method is nil but Interface.VgpuInstanceClearAccountingPids was just called")
	}
	callInfo := struct {
		VgpuInstance nvml.VgpuInstance
	}{
		VgpuInstance: vgpuInstance,
	}
	mock.lockVgpuInstanceClearAccountingPids.Lock()
	mock.calls.VgpuInstanceClearAccountingPids = append(mock.calls.VgpuInstanceClearAccountingPids, callInfo)
	mock.lockVgpuInstanceClearAccountingPids.Unlock()
	return mock.VgpuInstanceClearAccountingPidsFunc(vgpuInstance)
}

// VgpuInstanceClearAccountingPidsCalls gets all the calls that were made to VgpuInstanceClearAccountingPids.
// Check the length with:
//
//	len(mockedInterface.VgpuInstanceClearAccountingPidsCalls())
func (mock *Interface) VgpuInstanceClearAccountingPidsCalls() []struct {
	VgpuInstance nvml.VgpuInstance
} {
	var calls []struct {
		VgpuInstance nvml.VgpuInstance
	}
	mock.lockVgpuInstanceClearAccountingPids.RLock()
	calls = mock.calls.VgpuInstanceClearAccountingPids
	mock.lockVgpuInstanceClearAccountingPids.RUnlock()
	return calls
}

// VgpuInstanceGetAccountingMode calls VgpuInstanceGetAccountingModeFunc.
func (mock *Interface) VgpuInstanceGetAccountingMode(vgpuInstance nvml.VgpuInstance) (nvml.EnableState, nvml.Return) {
	if mock.VgpuInstanceGetAccountingModeFunc == nil {
		panic("Interface.VgpuInstanceGetAccountingModeFunc: method is nil but Interface.VgpuInstanceGetAccountingMode was just called")
	}
	callInfo := struct {
		VgpuInstance nvml.VgpuInstance
	}{
		VgpuInstance: vgpuInstance,
	}
	mock.lockVgpuInstanceGetAccountingMode.Lock()
	mock.calls.VgpuInstanceGetAccountingMode = append(mock.calls.VgpuInstanceGetAccountingMode, callInfo)
	mock.lockVgpuInstanceGetAccountingMode.Unlock()
	return mock.VgpuInstanceGetAccountingModeFunc(vgpuInstance)
}

// VgpuInstanceGetAccountingModeCalls gets all the calls that were made to VgpuInstanceGetAccountingMode.
// Check the length with:
//
//	len(mockedInterface.VgpuInstanceGetAccountingModeCalls())
func (mock *Interface) VgpuInstanceGetAccountingModeCalls() []struct {
	VgpuInstance nvml.VgpuInstance
} {
	var calls []struct {
		VgpuInstance nvml.VgpuInstance
	}
	mock.lockVgpuInstanceGetAccountingMode.RLock()
	calls = mock.calls.VgpuInstanceGetAccountingMode
	mock.lockVgpuInstanceGetAccountingMode.RUnlock()
	return calls
}

// VgpuInstanceGetAccountingPids calls VgpuInstanceGetAccountingPidsFunc.
func (mock *Interface) VgpuInstanceGetAccountingPids(vgpuInstance nvml.VgpuInstance) ([]int, nvml.Return) {
	if mock.VgpuInstanceGetAccountingPidsFunc == nil {
		panic("Interface.VgpuInstanceGetAccountingPidsFunc: method is nil but Interface.VgpuInstanceGetAccountingPids was just called")
	}
	callInfo := struct {
		VgpuInstance nvml.VgpuInstance
	}{
		VgpuInstance: vgpuInstance,
	}
	mock.lockVgpuInstanceGetAccountingPids.Lock()
	mock.calls.VgpuInstanceGetAccountingPids = append(mock.calls.VgpuInstanceGetAccountingPids, callInfo)
	mock.lockVgpuInstanceGetAccountingPids.Unlock()
	return mock.VgpuInstanceGetAccountingPidsFunc(vgpuInstance)
}

// VgpuInstanceGetAccountingPidsCalls gets all the calls that were made to VgpuInstanceGetAccountingPids.
// Check the length with:
//
//	len(mockedInterface.VgpuInstanceGetAccountingPidsCalls())
func (mock *Interface) VgpuInstanceGetAccountingPidsCalls() []struct {
	VgpuInstance nvml.VgpuInstance
} {
	var calls []struct {
		VgpuInstance nvml.VgpuInstance
	}
	mock.lockVgpuInstanceGetAccountingPids.RLock()
	calls = mock.calls.VgpuInstanceGetAccountingPids
	mock.lockVgpuInstanceGetAccountingPids.RUnlock()
	return calls
}

// VgpuInstanceGetAccountingStats calls VgpuInstanceGetAccountingStatsFunc.
func (mock *Interface) VgpuInstanceGetAccountingStats(vgpuInstance nvml.VgpuInstance, n int) (nvml.AccountingStats, nvml.Return) {
	if mock.VgpuInstanceGetAccountingStatsFunc == nil {
		panic("Interface.VgpuInstanceGetAccountingStatsFunc: method is nil but Interface.VgpuInstanceGetAccountingStats was just called")
	}
	callInfo := struct {
		VgpuInstance nvml.VgpuInstance
		N            int
	}{
		VgpuInstance: vgpuInstance,
		N:            n,
	}
	mock.lockVgpuInstanceGetAccountingStats.Lock()
	mock.calls.VgpuInstanceGetAccountingStats = append(mock.calls.VgpuInstanceGetAccountingStats, callInfo)
	mock.lockVgpuInstanceGetAccountingStats.Unlock()
	return mock.VgpuInstanceGetAccountingStatsFunc(vgpuInstance, n)
}

// VgpuInstanceGetAccountingStatsCalls gets all the calls that were made to VgpuInstanceGetAccountingStats.
// Check the length with:
//
//	len(mockedInterface.VgpuInstanceGetAccountingStatsCalls())
func (mock *Interface) VgpuInstanceGetAccountingStatsCalls() []struct {
	VgpuInstance nvml.VgpuInstance
	N            int
} {
	var calls []struct {
		VgpuInstance nvml.VgpuInstance
		N            int
	}
	mock.lockVgpuInstanceGetAccountingStats.RLock()
	calls = mock.calls.VgpuInstanceGetAccountingStats
	mock.lockVgpuInstanceGetAccountingStats.RUnlock()
	return calls
}

// VgpuInstanceGetEccMode calls VgpuInstanceGetEccModeFunc.
func (mock *Interface) VgpuInstanceGetEccMode(vgpuInstance nvml.VgpuInstance) (nvml.EnableState, nvml.Return) {
	if mock.VgpuInstanceGetEccModeFunc == nil {
		panic("Interface.VgpuInstanceGetEccModeFunc: method is nil but Interface.VgpuInstanceGetEccMode was just called")
	}
	callInfo := struct {
		VgpuInstance nvml.VgpuInstance
	}{
		VgpuInstance: vgpuInstance,
	}
	mock.lockVgpuInstanceGetEccMode.Lock()
	mock.calls.VgpuInstanceGetEccMode = append(mock.calls.VgpuInstanceGetEccMode, callInfo)
	mock.lockVgpuInstanceGetEccMode.Unlock()
	return mock.VgpuInstanceGetEccModeFunc(vgpuInstance)
}

// VgpuInstanceGetEccModeCalls gets all the calls that were made to VgpuInstanceGetEccMode.
// Check the length with:
//
//	len(mockedInterface.VgpuInstanceGetEccModeCalls())
func (mock *Interface) VgpuInstanceGetEccModeCalls() []struct {
	VgpuInstance nvml.VgpuInstance
} {
	var calls []struct {
		VgpuInstance nvml.VgpuInstance
	}
	mock.lockVgpuInstanceGetEccMode.RLock()
	calls = mock.calls.VgpuInstanceGetEccMode
	mock.lockVgpuInstanceGetEccMode.RUnlock()
	return calls
}

// VgpuInstanceGetEncoderCapacity calls VgpuInstanceGetEncoderCapacityFunc.
func (mock *Interface) VgpuInstanceGetEncoderCapacity(vgpuInstance nvml.VgpuInstance) (int, nvml.Return) {
	if mock.VgpuInstanceGetEncoderCapacityFunc == nil {
		panic("Interface.VgpuInstanceGetEncoderCapacityFunc: method is nil but Interface.VgpuInstanceGetEncoderCapacity was just called")
	}
	callInfo := struct {
		VgpuInstance nvml.VgpuInstance
	}{
		VgpuInstance: vgpuInstance,
	}
	mock.lockVgpuInstanceGetEncoderCapacity.Lock()
	mock.calls.VgpuInstanceGetEncoderCapacity = append(mock.calls.VgpuInstanceGetEncoderCapacity, callInfo)
	mock.lockVgpuInstanceGetEncoderCapacity.Unlock()
	return mock.VgpuInstanceGetEncoderCapacityFunc(vgpuInstance)
}

// VgpuInstanceGetEncoderCapacityCalls gets all the calls that were made to VgpuInstanceGetEncoderCapacity.
// Check the length with:
//
//	len(mockedInterface.VgpuInstanceGetEncoderCapacityCalls())
func (mock *Interface) VgpuInstanceGetEncoderCapacityCalls() []struct {
	VgpuInstance nvml.VgpuInstance
} {
	var calls []struct {
		VgpuInstance nvml.VgpuInstance
	}
	mock.lockVgpuInstanceGetEncoderCapacity.RLock()
	calls = mock.calls.VgpuInstanceGetEncoderCapacity
	mock.lockVgpuInstanceGetEncoderCapacity.RUnlock()
	return calls
}

// VgpuInstanceGetEncoderSessions calls VgpuInstanceGetEncoderSessionsFunc.
func (mock *Interface) VgpuInstanceGetEncoderSessions(vgpuInstance nvml.VgpuInstance) (int, nvml.EncoderSessionInfo, nvml.Return) {
	if mock.VgpuInstanceGetEncoderSessionsFunc == nil {
		panic("Interface.VgpuInstanceGetEncoderSessionsFunc: method is nil but Interface.VgpuInstanceGetEncoderSessions was just called")
	}
	callInfo := struct {
		VgpuInstance nvml.VgpuInstance
	}{
		VgpuInstance: vgpuInstance,
	}
	mock.lockVgpuInstanceGetEncoderSessions.Lock()
	mock.calls.VgpuInstanceGetEncoderSessions = append(mock.calls.VgpuInstanceGetEncoderSessions, callInfo)
	mock.lockVgpuInstanceGetEncoderSessions.Unlock()
	return mock.VgpuInstanceGetEncoderSessionsFunc(vgpuInstance)
}

// VgpuInstanceGetEncoderSessionsCalls gets all the calls that were made to VgpuInstanceGetEncoderSessions.
// Check the length with:
//
//	len(mockedInterface.VgpuInstanceGetEncoderSessionsCalls())
func (mock *Interface) VgpuInstanceGetEncoderSessionsCalls() []struct {
	VgpuInstance nvml.VgpuInstance
} {
	var calls []struct {
		VgpuInstance nvml.VgpuInstance
	}
	mock.lockVgpuInstanceGetEncoderSessions.RLock()
	calls = mock.calls.VgpuInstanceGetEncoderSessions
	mock.lockVgpuInstanceGetEncoderSessions.RUnlock()
	return calls
}

// VgpuInstanceGetEncoderStats calls VgpuInstanceGetEncoderStatsFunc.
func (mock *Interface) VgpuInstanceGetEncoderStats(vgpuInstance nvml.VgpuInstance) (int, uint32, uint32, nvml.Return) {
	if mock.VgpuInstanceGetEncoderStatsFunc == nil {
		panic("Interface.VgpuInstanceGetEncoderStatsFunc: method is nil but Interface.VgpuInstanceGetEncoderStats was just called")
	}
	callInfo := struct {
		VgpuInstance nvml.VgpuInstance
	}{
		VgpuInstance: vgpuInstance,
	}
	mock.lockVgpuInstanceGetEncoderStats.Lock()
	mock.calls.VgpuInstanceGetEncoderStats = append(mock.calls.VgpuInstanceGetEncoderStats, callInfo)
	mock.lockVgpuInstanceGetEncoderStats.Unlock()
	return mock.VgpuInstanceGetEncoderStatsFunc(vgpuInstance)
}

// VgpuInstanceGetEncoderStatsCalls gets all the calls that were made to VgpuInstanceGetEncoderStats.
// Check the length with:
//
//	len(mockedInterface.VgpuInstanceGetEncoderStatsCalls())
func (mock *Interface) VgpuInstanceGetEncoderStatsCalls() []struct {
	VgpuInstance nvml.VgpuInstance
} {
	var calls []struct {
		VgpuInstance nvml.VgpuInstance
	}
	mock.lockVgpuInstanceGetEncoderStats.RLock()
	calls = mock.calls.VgpuInstanceGetEncoderStats
	mock.lockVgpuInstanceGetEncoderStats.RUnlock()
	return calls
}

// VgpuInstanceGetFBCSessions calls VgpuInstanceGetFBCSessionsFunc.
func (mock *Interface) VgpuInstanceGetFBCSessions(vgpuInstance nvml.VgpuInstance) (int, nvml.FBCSessionInfo, nvml.Return) {
	if mock.VgpuInstanceGetFBCSessionsFunc == nil {
		panic("Interface.VgpuInstanceGetFBCSessionsFunc: method is nil but Interface.VgpuInstanceGetFBCSessions was just called")
	}
	callInfo := struct {
		VgpuInstance nvml.VgpuInstance
	}{
		VgpuInstance: vgpuInstance,
	}
	mock.lockVgpuInstanceGetFBCSessions.Lock()
	mock.calls.VgpuInstanceGetFBCSessions = append(mock.calls.VgpuInstanceGetFBCSessions, callInfo)
	mock.lockVgpuInstanceGetFBCSessions.Unlock()
	return mock.VgpuInstanceGetFBCSessionsFunc(vgpuInstance)
}

// VgpuInstanceGetFBCSessionsCalls gets all the calls that were made to VgpuInstanceGetFBCSessions.
// Check the length with:
//
//	len(mockedInterface.VgpuInstanceGetFBCSessionsCalls())
func (mock *Interface) VgpuInstanceGetFBCSessionsCalls() []struct {
	VgpuInstance nvml.VgpuInstance
} {
	var calls []struct {
		VgpuInstance nvml.VgpuInstance
	}
	mock.lockVgpuInstanceGetFBCSessions.RLock()
	calls = mock.calls.VgpuInstanceGetFBCSessions
	mock.lockVgpuInstanceGetFBCSessions.RUnlock()
	return calls
}

// VgpuInstanceGetFBCStats calls VgpuInstanceGetFBCStatsFunc.
func (mock *Interface) VgpuInstanceGetFBCStats(vgpuInstance nvml.VgpuInstance) (nvml.FBCStats, nvml.Return) {
	if mock.VgpuInstanceGetFBCStatsFunc == nil {
		panic("Interface.VgpuInstanceGetFBCStatsFunc: method is nil but Interface.VgpuInstanceGetFBCStats was just called")
	}
	callInfo := struct {
		VgpuInstance nvml.VgpuInstance
	}{
		VgpuInstance: vgpuInstance,
	}
	mock.lockVgpuInstanceGetFBCStats.Lock()
	mock.calls.VgpuInstanceGetFBCStats = append(mock.calls.VgpuInstanceGetFBCStats, callInfo)
	mock.lockVgpuInstanceGetFBCStats.Unlock()
	return mock.VgpuInstanceGetFBCStatsFunc(vgpuInstance)
}

// VgpuInstanceGetFBCStatsCalls gets all the calls that were made to VgpuInstanceGetFBCStats.
// Check the length with:
//
//	len(mockedInterface.VgpuInstanceGetFBCStatsCalls())
func (mock *Interface) VgpuInstanceGetFBCStatsCalls() []struct {
	VgpuInstance nvml.VgpuInstance
} {
	var calls []struct {
		VgpuInstance nvml.VgpuInstance
	}
	mock.lockVgpuInstanceGetFBCStats.RLock()
	calls = mock.calls.VgpuInstanceGetFBCStats
	mock.lockVgpuInstanceGetFBCStats.RUnlock()
	return calls
}

// VgpuInstanceGetFbUsage calls VgpuInstanceGetFbUsageFunc.
func (mock *Interface) VgpuInstanceGetFbUsage(vgpuInstance nvml.VgpuInstance) (uint64, nvml.Return) {
	if mock.VgpuInstanceGetFbUsageFunc == nil {
		panic("Interface.VgpuInstanceGetFbUsageFunc: method is nil but Interface.VgpuInstanceGetFbUsage was just called")
	}
	callInfo := struct {
		VgpuInstance nvml.VgpuInstance
	}{
		VgpuInstance: vgpuInstance,
	}
	mock.lockVgpuInstanceGetFbUsage.Lock()
	mock.calls.VgpuInstanceGetFbUsage = append(mock.calls.VgpuInstanceGetFbUsage, callInfo)
	mock.lockVgpuInstanceGetFbUsage.Unlock()
	return mock.VgpuInstanceGetFbUsageFunc(vgpuInstance)
}

// VgpuInstanceGetFbUsageCalls gets all the calls that were made to VgpuInstanceGetFbUsage.
// Check the length with:
//
//	len(mockedInterface.VgpuInstanceGetFbUsageCalls())
func (mock *Interface) VgpuInstanceGetFbUsageCalls() []struct {
	VgpuInstance nvml.VgpuInstance
} {
	var calls []struct {
		VgpuInstance nvml.VgpuInstance
	}
	mock.lockVgpuInstanceGetFbUsage.RLock()
	calls = mock.calls.VgpuInstanceGetFbUsage
	mock.lockVgpuInstanceGetFbUsage.RUnlock()
	return calls
}

// VgpuInstanceGetFrameRateLimit calls VgpuInstanceGetFrameRateLimitFunc.
func (mock *Interface) VgpuInstanceGetFrameRateLimit(vgpuInstance nvml.VgpuInstance) (uint32, nvml.Return) {
	if mock.VgpuInstanceGetFrameRateLimitFunc == nil {
		panic("Interface.VgpuInstanceGetFrameRateLimitFunc: method is nil but Interface.VgpuInstanceGetFrameRateLimit was just called")
	}
	callInfo := struct {
		VgpuInstance nvml.VgpuInstance
	}{
		VgpuInstance: vgpuInstance,
	}
	mock.lockVgpuInstanceGetFrameRateLimit.Lock()
	mock.calls.VgpuInstanceGetFrameRateLimit = append(mock.calls.VgpuInstanceGetFrameRateLimit, callInfo)
	mock.lockVgpuInstanceGetFrameRateLimit.Unlock()
	return mock.VgpuInstanceGetFrameRateLimitFunc(vgpuInstance)
}

// VgpuInstanceGetFrameRateLimitCalls gets all the calls that were made to VgpuInstanceGetFrameRateLimit.
// Check the length with:
//
//	len(mockedInterface.VgpuInstanceGetFrameRateLimitCalls())
func (mock *Interface) VgpuInstanceGetFrameRateLimitCalls() []struct {
	VgpuInstance nvml.VgpuInstance
} {
	var calls []struct {
		VgpuInstance nvml.VgpuInstance
	}
	mock.lockVgpuInstanceGetFrameRateLimit.RLock()
	calls = mock.calls.VgpuInstanceGetFrameRateLimit
	mock.lockVgpuInstanceGetFrameRateLimit.RUnlock()
	return calls
}

// VgpuInstanceGetGpuInstanceId calls VgpuInstanceGetGpuInstanceIdFunc.
func (mock *Interface) VgpuInstanceGetGpuInstanceId(vgpuInstance nvml.VgpuInstance) (int, nvml.Return) {
	if mock.VgpuInstanceGetGpuInstanceIdFunc == nil {
		panic("Interface.VgpuInstanceGetGpuInstanceIdFunc: method is nil but Interface.VgpuInstanceGetGpuInstanceId was just called")
	}
	callInfo := struct {
		VgpuInstance nvml.VgpuInstance
	}{
		VgpuInstance: vgpuInstance,
	}
	mock.lockVgpuInstanceGetGpuInstanceId.Lock()
	mock.calls.VgpuInstanceGetGpuInstanceId = append(mock.calls.VgpuInstanceGetGpuInstanceId, callInfo)
	mock.lockVgpuInstanceGetGpuInstanceId.Unlock()
	return mock.VgpuInstanceGetGpuInstanceIdFunc(vgpuInstance)
}

// VgpuInstanceGetGpuInstanceIdCalls gets all the calls that were made to VgpuInstanceGetGpuInstanceId.
// Check the length with:
//
//	len(mockedInterface.VgpuInstanceGetGpuInstanceIdCalls())
func (mock *Interface) VgpuInstanceGetGpuInstanceIdCalls() []struct {
	VgpuInstance nvml.VgpuInstance
} {
	var calls []struct {
		VgpuInstance nvml.VgpuInstance
	}
	mock.lockVgpuInstanceGetGpuInstanceId.RLock()
	calls = mock.calls.VgpuInstanceGetGpuInstanceId
	mock.lockVgpuInstanceGetGpuInstanceId.RUnlock()
	return calls
}

// VgpuInstanceGetGpuPciId calls VgpuInstanceGetGpuPciIdFunc.
func (mock *Interface) VgpuInstanceGetGpuPciId(vgpuInstance nvml.VgpuInstance) (string, nvml.Return) {
	if mock.VgpuInstanceGetGpuPciIdFunc == nil {
		panic("Interface.VgpuInstanceGetGpuPciIdFunc: method is nil but Interface.VgpuInstanceGetGpuPciId was just called")
	}
	callInfo := struct {
		VgpuInstance nvml.VgpuInstance
	}{
		VgpuInstance: vgpuInstance,
	}
	mock.lockVgpuInstanceGetGpuPciId.Lock()
	mock.calls.VgpuInstanceGetGpuPciId = append(mock.calls.VgpuInstanceGetGpuPciId, callInfo)
	mock.lockVgpuInstanceGetGpuPciId.Unlock()
	return mock.VgpuInstanceGetGpuPciIdFunc(vgpuInstance)
}

// VgpuInstanceGetGpuPciIdCalls gets all the calls that were made to VgpuInstanceGetGpuPciId.
// Check the length with:
//
//	len(mockedInterface.VgpuInstanceGetGpuPciIdCalls())
func (mock *Interface) VgpuInstanceGetGpuPciIdCalls() []struct {
	VgpuInstance nvml.VgpuInstance
} {
	var calls []struct {
		VgpuInstance nvml.VgpuInstance
	}
	mock.lockVgpuInstanceGetGpuPciId.RLock()
	calls = mock.calls.VgpuInstanceGetGpuPciId
	mock.lockVgpuInstanceGetGpuPciId.RUnlock()
	return calls
}

// VgpuInstanceGetLicenseInfo calls VgpuInstanceGetLicenseInfoFunc.
func (mock *Interface) VgpuInstanceGetLicenseInfo(vgpuInstance nvml.VgpuInstance) (nvml.VgpuLicenseInfo, nvml.Return) {
	if mock.VgpuInstanceGetLicenseInfoFunc == nil {
		panic("Interface.VgpuInstanceGetLicenseInfoFunc: method is nil but Interface.VgpuInstanceGetLicenseInfo was just called")
	}
	callInfo := struct {
		VgpuInstance nvml.VgpuInstance
	}{
		VgpuInstance: vgpuInstance,
	}
	mock.lockVgpuInstanceGetLicenseInfo.Lock()
	mock.calls.VgpuInstanceGetLicenseInfo = append(mock.calls.VgpuInstanceGetLicenseInfo, callInfo)
	mock.lockVgpuInstanceGetLicenseInfo.Unlock()
	return mock.VgpuInstanceGetLicenseInfoFunc(vgpuInstance)
}

// VgpuInstanceGetLicenseInfoCalls gets all the calls that were made to VgpuInstanceGetLicenseInfo.
// Check the length with:
//
//	len(mockedInterface.VgpuInstanceGetLicenseInfoCalls())
func (mock *Interface) VgpuInstanceGetLicenseInfoCalls() []struct {
	VgpuInstance nvml.VgpuInstance
} {
	var calls []struct {
		VgpuInstance nvml.VgpuInstance
	}
	mock.lockVgpuInstanceGetLicenseInfo.RLock()
	calls = mock.calls.VgpuInstanceGetLicenseInfo
	mock.lockVgpuInstanceGetLicenseInfo.RUnlock()
	return calls
}

// VgpuInstanceGetLicenseStatus calls VgpuInstanceGetLicenseStatusFunc.
func (mock *Interface) VgpuInstanceGetLicenseStatus(vgpuInstance nvml.VgpuInstance) (int, nvml.Return) {
	if mock.VgpuInstanceGetLicenseStatusFunc == nil {
		panic("Interface.VgpuInstanceGetLicenseStatusFunc: method is nil but Interface.VgpuInstanceGetLicenseStatus was just called")
	}
	callInfo := struct {
		VgpuInstance nvml.VgpuInstance
	}{
		VgpuInstance: vgpuInstance,
	}
	mock.lockVgpuInstanceGetLicenseStatus.Lock()
	mock.calls.VgpuInstanceGetLicenseStatus = append(mock.calls.VgpuInstanceGetLicenseStatus, callInfo)
	mock.lockVgpuInstanceGetLicenseStatus.Unlock()
	return mock.VgpuInstanceGetLicenseStatusFunc(vgpuInstance)
}

// VgpuInstanceGetLicenseStatusCalls gets all the calls that were made to VgpuInstanceGetLicenseStatus.
// Check the length with:
//
//	len(mockedInterface.VgpuInstanceGetLicenseStatusCalls())
func (mock *Interface) VgpuInstanceGetLicenseStatusCalls() []struct {
	VgpuInstance nvml.VgpuInstance
} {
	var calls []struct {
		VgpuInstance nvml.VgpuInstance
	}
	mock.lockVgpuInstanceGetLicenseStatus.RLock()
	calls = mock.calls.VgpuInstanceGetLicenseStatus
	mock.lockVgpuInstanceGetLicenseStatus.RUnlock()
	return calls
}

// VgpuInstanceGetMdevUUID calls VgpuInstanceGetMdevUUIDFunc.
func (mock *Interface) VgpuInstanceGetMdevUUID(vgpuInstance nvml.VgpuInstance) (string, nvml.Return) {
	if mock.VgpuInstanceGetMdevUUIDFunc == nil {
		panic("Interface.VgpuInstanceGetMdevUUIDFunc: method is nil but Interface.VgpuInstanceGetMdevUUID was just called")
	}
	callInfo := struct {
		VgpuInstance nvml.VgpuInstance
	}{
		VgpuInstance: vgpuInstance,
	}
	mock.lockVgpuInstanceGetMdevUUID.Lock()
	mock.calls.VgpuInstanceGetMdevUUID = append(mock.calls.VgpuInstanceGetMdevUUID, callInfo)
	mock.lockVgpuInstanceGetMdevUUID.Unlock()
	return mock.VgpuInstanceGetMdevUUIDFunc(vgpuInstance)
}

// VgpuInstanceGetMdevUUIDCalls gets all the calls that were made to VgpuInstanceGetMdevUUID.
// Check the length with:
//
//	len(mockedInterface.VgpuInstanceGetMdevUUIDCalls())
func (mock *Interface) VgpuInstanceGetMdevUUIDCalls() []struct {
	VgpuInstance nvml.VgpuInstance
} {
	var calls []struct {
		VgpuInstance nvml.VgpuInstance
	}
	mock.lockVgpuInstanceGetMdevUUID.RLock()
	calls = mock.calls.VgpuInstanceGetMdevUUID
	mock.lockVgpuInstanceGetMdevUUID.RUnlock()
	return calls
}

// VgpuInstanceGetMetadata calls VgpuInstanceGetMetadataFunc.
func (mock *Interface) VgpuInstanceGetMetadata(vgpuInstance nvml.VgpuInstance) (nvml.VgpuMetadata, nvml.Return) {
	if mock.VgpuInstanceGetMetadataFunc == nil {
		panic("Interface.VgpuInstanceGetMetadataFunc: method is nil but Interface.VgpuInstanceGetMetadata was just called")
	}
	callInfo := struct {
		VgpuInstance nvml.VgpuInstance
	}{
		VgpuInstance: vgpuInstance,
	}
	mock.lockVgpuInstanceGetMetadata.Lock()
	mock.calls.VgpuInstanceGetMetadata = append(mock.calls.VgpuInstanceGetMetadata, callInfo)
	mock.lockVgpuInstanceGetMetadata.Unlock()
	return mock.VgpuInstanceGetMetadataFunc(vgpuInstance)
}

// VgpuInstanceGetMetadataCalls gets all the calls that were made to VgpuInstanceGetMetadata.
// Check the length with:
//
//	len(mockedInterface.VgpuInstanceGetMetadataCalls())
func (mock *Interface) VgpuInstanceGetMetadataCalls() []struct {
	VgpuInstance nvml.VgpuInstance
} {
	var calls []struct {
		VgpuInstance nvml.VgpuInstance
	}
	mock.lockVgpuInstanceGetMetadata.RLock()
	calls = mock.calls.VgpuInstanceGetMetadata
	mock.lockVgpuInstanceGetMetadata.RUnlock()
	return calls
}

// VgpuInstanceGetRuntimeStateSize calls VgpuInstanceGetRuntimeStateSizeFunc.
func (mock *Interface) VgpuInstanceGetRuntimeStateSize(vgpuInstance nvml.VgpuInstance) (nvml.VgpuRuntimeState, nvml.Return) {
	if mock.VgpuInstanceGetRuntimeStateSizeFunc == nil {
		panic("Interface.VgpuInstanceGetRuntimeStateSizeFunc: method is nil but Interface.VgpuInstanceGetRuntimeStateSize was just called")
	}
	callInfo := struct {
		VgpuInstance nvml.VgpuInstance
	}{
		VgpuInstance: vgpuInstance,
	}
	mock.lockVgpuInstanceGetRuntimeStateSize.Lock()
	mock.calls.VgpuInstanceGetRuntimeStateSize = append(mock.calls.VgpuInstanceGetRuntimeStateSize, callInfo)
	mock.lockVgpuInstanceGetRuntimeStateSize.Unlock()
	return mock.VgpuInstanceGetRuntimeStateSizeFunc(vgpuInstance)
}

// VgpuInstanceGetRuntimeStateSizeCalls gets all the calls that were made to VgpuInstanceGetRuntimeStateSize.
// Check the length with:
//
//	len(mockedInterface.VgpuInstanceGetRuntimeStateSizeCalls())
func (mock *Interface) VgpuInstanceGetRuntimeStateSizeCalls() []struct {
	VgpuInstance nvml.VgpuInstance
} {
	var calls []struct {
		VgpuInstance nvml.VgpuInstance
	}
	mock.lockVgpuInstanceGetRuntimeStateSize.RLock()
	calls = mock.calls.VgpuInstanceGetRuntimeStateSize
	mock.lockVgpuInstanceGetRuntimeStateSize.RUnlock()
	return calls
}

// VgpuInstanceGetType calls VgpuInstanceGetTypeFunc.
func (mock *Interface) VgpuInstanceGetType(vgpuInstance nvml.VgpuInstance) (nvml.VgpuTypeId, nvml.Return) {
	if mock.VgpuInstanceGetTypeFunc == nil {
		panic("Interface.VgpuInstanceGetTypeFunc: method is nil but Interface.VgpuInstanceGetType was just called")
	}
	callInfo := struct {
		VgpuInstance nvml.VgpuInstance
	}{
		VgpuInstance: vgpuInstance,
	}
	mock.lockVgpuInstanceGetType.Lock()
	mock.calls.VgpuInstanceGetType = append(mock.calls.VgpuInstanceGetType, callInfo)
	mock.lockVgpuInstanceGetType.Unlock()
	return mock.VgpuInstanceGetTypeFunc(vgpuInstance)
}

// VgpuInstanceGetTypeCalls gets all the calls that were made to VgpuInstanceGetType.
// Check the length with:
//
//	len(mockedInterface.VgpuInstanceGetTypeCalls())
func (mock *Interface) VgpuInstanceGetTypeCalls() []struct {
	VgpuInstance nvml.VgpuInstance
} {
	var calls []struct {
		VgpuInstance nvml.VgpuInstance
	}
	mock.lockVgpuInstanceGetType.RLock()
	calls = mock.calls.VgpuInstanceGetType
	mock.lockVgpuInstanceGetType.RUnlock()
	return calls
}

// VgpuInstanceGetUUID calls VgpuInstanceGetUUIDFunc.
func (mock *Interface) VgpuInstanceGetUUID(vgpuInstance nvml.VgpuInstance) (string, nvml.Return) {
	if mock.VgpuInstanceGetUUIDFunc == nil {
		panic("Interface.VgpuInstanceGetUUIDFunc: method is nil but Interface.VgpuInstanceGetUUID was just called")
	}
	callInfo := struct {
		VgpuInstance nvml.VgpuInstance
	}{
		VgpuInstance: vgpuInstance,
	}
	mock.lockVgpuInstanceGetUUID.Lock()
	mock.calls.VgpuInstanceGetUUID = append(mock.calls.VgpuInstanceGetUUID, callInfo)
	mock.lockVgpuInstanceGetUUID.Unlock()
	return mock.VgpuInstanceGetUUIDFunc(vgpuInstance)
}

// VgpuInstanceGetUUIDCalls gets all the calls that were made to VgpuInstanceGetUUID.
// Check the length with:
//
//	len(mockedInterface.VgpuInstanceGetUUIDCalls())
func (mock *Interface) VgpuInstanceGetUUIDCalls() []struct {
	VgpuInstance nvml.VgpuInstance
} {
	var calls []struct {
		VgpuInstance nvml.VgpuInstance
	}
	mock.lockVgpuInstanceGetUUID.RLock()
	calls = mock.calls.VgpuInstanceGetUUID
	mock.lockVgpuInstanceGetUUID.RUnlock()
	return calls
}

// VgpuInstanceGetVmDriverVersion calls VgpuInstanceGetVmDriverVersionFunc.
func (mock *Interface) VgpuInstanceGetVmDriverVersion(vgpuInstance nvml.VgpuInstance) (string, nvml.Return) {
	if mock.VgpuInstanceGetVmDriverVersionFunc == nil {
		panic("Interface.VgpuInstanceGetVmDriverVersionFunc: method is nil but Interface.VgpuInstanceGetVmDriverVersion was just called")
	}
	callInfo := struct {
		VgpuInstance nvml.VgpuInstance
	}{
		VgpuInstance: vgpuInstance,
	}
	mock.lockVgpuInstanceGetVmDriverVersion.Lock()
	mock.calls.VgpuInstanceGetVmDriverVersion = append(mock.calls.VgpuInstanceGetVmDriverVersion, callInfo)
	mock.lockVgpuInstanceGetVmDriverVersion.Unlock()
	return mock.VgpuInstanceGetVmDriverVersionFunc(vgpuInstance)
}

// VgpuInstanceGetVmDriverVersionCalls gets all the calls that were made to VgpuInstanceGetVmDriverVersion.
// Check the length with:
//
//	len(mockedInterface.VgpuInstanceGetVmDriverVersionCalls())
func (mock *Interface) VgpuInstanceGetVmDriverVersionCalls() []struct {
	VgpuInstance nvml.VgpuInstance
} {
	var calls []struct {
		VgpuInstance nvml.VgpuInstance
	}
	mock.lockVgpuInstanceGetVmDriverVersion.RLock()
	calls = mock.calls.VgpuInstanceGetVmDriverVersion
	mock.lockVgpuInstanceGetVmDriverVersion.RUnlock()
	return calls
}

// VgpuInstanceGetVmID calls VgpuInstanceGetVmIDFunc.
func (mock *Interface) VgpuInstanceGetVmID(vgpuInstance nvml.VgpuInstance) (string, nvml.VgpuVmIdType, nvml.Return) {
	if mock.VgpuInstanceGetVmIDFunc == nil {
		panic("Interface.VgpuInstanceGetVmIDFunc: method is nil but Interface.VgpuInstanceGetVmID was just called")
	}
	callInfo := struct {
		VgpuInstance nvml.VgpuInstance
	}{
		VgpuInstance: vgpuInstance,
	}
	mock.lockVgpuInstanceGetVmID.Lock()
	mock.calls.VgpuInstanceGetVmID = append(mock.calls.VgpuInstanceGetVmID, callInfo)
	mock.lockVgpuInstanceGetVmID.Unlock()
	return mock.VgpuInstanceGetVmIDFunc(vgpuInstance)
}

// VgpuInstanceGetVmIDCalls gets all the calls that were made to VgpuInstanceGetVmID.
// Check the length with:
//
//	len(mockedInterface.VgpuInstanceGetVmIDCalls())
func (mock *Interface) VgpuInstanceGetVmIDCalls() []struct {
	VgpuInstance nvml.VgpuInstance
} {
	var calls []struct {
		VgpuInstance nvml.VgpuInstance
	}
	mock.lockVgpuInstanceGetVmID.RLock()
	calls = mock.calls.VgpuInstanceGetVmID
	mock.lockVgpuInstanceGetVmID.RUnlock()
	return calls
}

// VgpuInstanceSetEncoderCapacity calls VgpuInstanceSetEncoderCapacityFunc.
func (mock *Interface) VgpuInstanceSetEncoderCapacity(vgpuInstance nvml.VgpuInstance, n int) nvml.Return {
	if mock.VgpuInstanceSetEncoderCapacityFunc == nil {
		panic("Interface.VgpuInstanceSetEncoderCapacityFunc: method is nil but Interface.VgpuInstanceSetEncoderCapacity was just called")
	}
	callInfo := struct {
		VgpuInstance nvml.VgpuInstance
		N            int
	}{
		VgpuInstance: vgpuInstance,
		N:            n,
	}
	mock.lockVgpuInstanceSetEncoderCapacity.Lock()
	mock.calls.VgpuInstanceSetEncoderCapacity = append(mock.calls.VgpuInstanceSetEncoderCapacity, callInfo)
	mock.lockVgpuInstanceSetEncoderCapacity.Unlock()
	return mock.VgpuInstanceSetEncoderCapacityFunc(vgpuInstance, n)
}

// VgpuInstanceSetEncoderCapacityCalls gets all the calls that were made to VgpuInstanceSetEncoderCapacity.
// Check the length with:
//
//	len(mockedInterface.VgpuInstanceSetEncoderCapacityCalls())
func (mock *Interface) VgpuInstanceSetEncoderCapacityCalls() []struct {
	VgpuInstance nvml.VgpuInstance
	N            int
} {
	var calls []struct {
		VgpuInstance nvml.VgpuInstance
		N            int
	}
	mock.lockVgpuInstanceSetEncoderCapacity.RLock()
	calls = mock.calls.VgpuInstanceSetEncoderCapacity
	mock.lockVgpuInstanceSetEncoderCapacity.RUnlock()
	return calls
}

// VgpuTypeGetBAR1Info calls VgpuTypeGetBAR1InfoFunc.
func (mock *Interface) VgpuTypeGetBAR1Info(vgpuTypeId nvml.VgpuTypeId) (nvml.VgpuTypeBar1Info, nvml.Return) {
	if mock.VgpuTypeGetBAR1InfoFunc == nil {
		panic("Interface.VgpuTypeGetBAR1InfoFunc: method is nil but Interface.VgpuTypeGetBAR1Info was just called")
	}
	callInfo := struct {
		VgpuTypeId nvml.VgpuTypeId
	}{
		VgpuTypeId: vgpuTypeId,
	}
	mock.lockVgpuTypeGetBAR1Info.Lock()
	mock.calls.VgpuTypeGetBAR1Info = append(mock.calls.VgpuTypeGetBAR1Info, callInfo)
	mock.lockVgpuTypeGetBAR1Info.Unlock()
	return mock.VgpuTypeGetBAR1InfoFunc(vgpuTypeId)
}

// VgpuTypeGetBAR1InfoCalls gets all the calls that were made to VgpuTypeGetBAR1Info.
// Check the length with:
//
//	len(mockedInterface.VgpuTypeGetBAR1InfoCalls())
func (mock *Interface) VgpuTypeGetBAR1InfoCalls() []struct {
	VgpuTypeId nvml.VgpuTypeId
} {
	var calls []struct {
		VgpuTypeId nvml.VgpuTypeId
	}
	mock.lockVgpuTypeGetBAR1Info.RLock()
	calls = mock.calls.VgpuTypeGetBAR1Info
	mock.lockVgpuTypeGetBAR1Info.RUnlock()
	return calls
}

// VgpuTypeGetCapabilities calls VgpuTypeGetCapabilitiesFunc.
func (mock *Interface) VgpuTypeGetCapabilities(vgpuTypeId nvml.VgpuTypeId, vgpuCapability nvml.VgpuCapability) (bool, nvml.Return) {
	if mock.VgpuTypeGetCapabilitiesFunc == nil {
		panic("Interface.VgpuTypeGetCapabilitiesFunc: method is nil but Interface.VgpuTypeGetCapabilities was just called")
	}
	callInfo := struct {
		VgpuTypeId     nvml.VgpuTypeId
		VgpuCapability nvml.VgpuCapability
	}{
		VgpuTypeId:     vgpuTypeId,
		VgpuCapability: vgpuCapability,
	}
	mock.lockVgpuTypeGetCapabilities.Lock()
	mock.calls.VgpuTypeGetCapabilities = append(mock.calls.VgpuTypeGetCapabilities, callInfo)
	mock.lockVgpuTypeGetCapabilities.Unlock()
	return mock.VgpuTypeGetCapabilitiesFunc(vgpuTypeId, vgpuCapability)
}

// VgpuTypeGetCapabilitiesCalls gets all the calls that were made to VgpuTypeGetCapabilities.
// Check the length with:
//
//	len(mockedInterface.VgpuTypeGetCapabilitiesCalls())
func (mock *Interface) VgpuTypeGetCapabilitiesCalls() []struct {
	VgpuTypeId     nvml.VgpuTypeId
	VgpuCapability nvml.VgpuCapability
} {
	var calls []struct {
		VgpuTypeId     nvml.VgpuTypeId
		VgpuCapability nvml.VgpuCapability
	}
	mock.lockVgpuTypeGetCapabilities.RLock()
	calls = mock.calls.VgpuTypeGetCapabilities
	mock.lockVgpuTypeGetCapabilities.RUnlock()
	return calls
}

// VgpuTypeGetClass calls VgpuTypeGetClassFunc.
func (mock *Interface) VgpuTypeGetClass(vgpuTypeId nvml.VgpuTypeId) (string, nvml.Return) {
	if mock.VgpuTypeGetClassFunc == nil {
		panic("Interface.VgpuTypeGetClassFunc: method is nil but Interface.VgpuTypeGetClass was just called")
	}
	callInfo := struct {
		VgpuTypeId nvml.VgpuTypeId
	}{
		VgpuTypeId: vgpuTypeId,
	}
	mock.lockVgpuTypeGetClass.Lock()
	mock.calls.VgpuTypeGetClass = append(mock.calls.VgpuTypeGetClass, callInfo)
	mock.lockVgpuTypeGetClass.Unlock()
	return mock.VgpuTypeGetClassFunc(vgpuTypeId)
}

// VgpuTypeGetClassCalls gets all the calls that were made to VgpuTypeGetClass.
// Check the length with:
//
//	len(mockedInterface.VgpuTypeGetClassCalls())
func (mock *Interface) VgpuTypeGetClassCalls() []struct {
	VgpuTypeId nvml.VgpuTypeId
} {
	var calls []struct {
		VgpuTypeId nvml.VgpuTypeId
	}
	mock.lockVgpuTypeGetClass.RLock()
	calls = mock.calls.VgpuTypeGetClass
	mock.lockVgpuTypeGetClass.RUnlock()
	return calls
}

// VgpuTypeGetDeviceID calls VgpuTypeGetDeviceIDFunc.
func (mock *Interface) VgpuTypeGetDeviceID(vgpuTypeId nvml.VgpuTypeId) (uint64, uint64, nvml.Return) {
	if mock.VgpuTypeGetDeviceIDFunc == nil {
		panic("Interface.VgpuTypeGetDeviceIDFunc: method is nil but Interface.VgpuTypeGetDeviceID was just called")
	}
	callInfo := struct {
		VgpuTypeId nvml.VgpuTypeId
	}{
		VgpuTypeId: vgpuTypeId,
	}
	mock.lockVgpuTypeGetDeviceID.Lock()
	mock.calls.VgpuTypeGetDeviceID = append(mock.calls.VgpuTypeGetDeviceID, callInfo)
	mock.lockVgpuTypeGetDeviceID.Unlock()
	return mock.VgpuTypeGetDeviceIDFunc(vgpuTypeId)
}

// VgpuTypeGetDeviceIDCalls gets all the calls that were made to VgpuTypeGetDeviceID.
// Check the length with:
//
//	len(mockedInterface.VgpuTypeGetDeviceIDCalls())
func (mock *Interface) VgpuTypeGetDeviceIDCalls() []struct {
	VgpuTypeId nvml.VgpuTypeId
} {
	var calls []struct {
		VgpuTypeId nvml.VgpuTypeId
	}
	mock.lockVgpuTypeGetDeviceID.RLock()
	calls = mock.calls.VgpuTypeGetDeviceID
	mock.lockVgpuTypeGetDeviceID.RUnlock()
	return calls
}

// VgpuTypeGetFrameRateLimit calls VgpuTypeGetFrameRateLimitFunc.
func (mock *Interface) VgpuTypeGetFrameRateLimit(vgpuTypeId nvml.VgpuTypeId) (uint32, nvml.Return) {
	if mock.VgpuTypeGetFrameRateLimitFunc == nil {
		panic("Interface.VgpuTypeGetFrameRateLimitFunc: method is nil but Interface.VgpuTypeGetFrameRateLimit was just called")
	}
	callInfo := struct {
		VgpuTypeId nvml.VgpuTypeId
	}{
		VgpuTypeId: vgpuTypeId,
	}
	mock.lockVgpuTypeGetFrameRateLimit.Lock()
	mock.calls.VgpuTypeGetFrameRateLimit = append(mock.calls.VgpuTypeGetFrameRateLimit, callInfo)
	mock.lockVgpuTypeGetFrameRateLimit.Unlock()
	return mock.VgpuTypeGetFrameRateLimitFunc(vgpuTypeId)
}

// VgpuTypeGetFrameRateLimitCalls gets all the calls that were made to VgpuTypeGetFrameRateLimit.
// Check the length with:
//
//	len(mockedInterface.VgpuTypeGetFrameRateLimitCalls())
func (mock *Interface) VgpuTypeGetFrameRateLimitCalls() []struct {
	VgpuTypeId nvml.VgpuTypeId
} {
	var calls []struct {
		VgpuTypeId nvml.VgpuTypeId
	}
	mock.lockVgpuTypeGetFrameRateLimit.RLock()
	calls = mock.calls.VgpuTypeGetFrameRateLimit
	mock.lockVgpuTypeGetFrameRateLimit.RUnlock()
	return calls
}

// VgpuTypeGetFramebufferSize calls VgpuTypeGetFramebufferSizeFunc.
func (mock *Interface) VgpuTypeGetFramebufferSize(vgpuTypeId nvml.VgpuTypeId) (uint64, nvml.Return) {
	if mock.VgpuTypeGetFramebufferSizeFunc == nil {
		panic("Interface.VgpuTypeGetFramebufferSizeFunc: method is nil but Interface.VgpuTypeGetFramebufferSize was just called")
	}
	callInfo := struct {
		VgpuTypeId nvml.VgpuTypeId
	}{
		VgpuTypeId: vgpuTypeId,
	}
	mock.lockVgpuTypeGetFramebufferSize.Lock()
	mock.calls.VgpuTypeGetFramebufferSize = append(mock.calls.VgpuTypeGetFramebufferSize, callInfo)
	mock.lockVgpuTypeGetFramebufferSize.Unlock()
	return mock.VgpuTypeGetFramebufferSizeFunc(vgpuTypeId)
}

// VgpuTypeGetFramebufferSizeCalls gets all the calls that were made to VgpuTypeGetFramebufferSize.
// Check the length with:
//
//	len(mockedInterface.VgpuTypeGetFramebufferSizeCalls())
func (mock *Interface) VgpuTypeGetFramebufferSizeCalls() []struct {
	VgpuTypeId nvml.VgpuTypeId
} {
	var calls []struct {
		VgpuTypeId nvml.VgpuTypeId
	}
	mock.lockVgpuTypeGetFramebufferSize.RLock()
	calls = mock.calls.VgpuTypeGetFramebufferSize
	mock.lockVgpuTypeGetFramebufferSize.RUnlock()
	return calls
}

// VgpuTypeGetGpuInstanceProfileId calls VgpuTypeGetGpuInstanceProfileIdFunc.
func (mock *Interface) VgpuTypeGetGpuInstanceProfileId(vgpuTypeId nvml.VgpuTypeId) (uint32, nvml.Return) {
	if mock.VgpuTypeGetGpuInstanceProfileIdFunc == nil {
		panic("Interface.VgpuTypeGetGpuInstanceProfileIdFunc: method is nil but Interface.VgpuTypeGetGpuInstanceProfileId was just called")
	}
	callInfo := struct {
		VgpuTypeId nvml.VgpuTypeId
	}{
		VgpuTypeId: vgpuTypeId,
	}
	mock.lockVgpuTypeGetGpuInstanceProfileId.Lock()
	mock.calls.VgpuTypeGetGpuInstanceProfileId = append(mock.calls.VgpuTypeGetGpuInstanceProfileId, callInfo)
	mock.lockVgpuTypeGetGpuInstanceProfileId.Unlock()
	return mock.VgpuTypeGetGpuInstanceProfileIdFunc(vgpuTypeId)
}

// VgpuTypeGetGpuInstanceProfileIdCalls gets all the calls that were made to VgpuTypeGetGpuInstanceProfileId.
// Check the length with:
//
//	len(mockedInterface.VgpuTypeGetGpuInstanceProfileIdCalls())
func (mock *Interface) VgpuTypeGetGpuInstanceProfileIdCalls() []struct {
	VgpuTypeId nvml.VgpuTypeId
} {
	var calls []struct {
		VgpuTypeId nvml.VgpuTypeId
	}
	mock.lockVgpuTypeGetGpuInstanceProfileId.RLock()
	calls = mock.calls.VgpuTypeGetGpuInstanceProfileId
	mock.lockVgpuTypeGetGpuInstanceProfileId.RUnlock()
	return calls
}

// VgpuTypeGetLicense calls VgpuTypeGetLicenseFunc.
func (mock *Interface) VgpuTypeGetLicense(vgpuTypeId nvml.VgpuTypeId) (string, nvml.Return) {
	if mock.VgpuTypeGetLicenseFunc == nil {
		panic("Interface.VgpuTypeGetLicenseFunc: method is nil but Interface.VgpuTypeGetLicense was just called")
	}
	callInfo := struct {
		VgpuTypeId nvml.VgpuTypeId
	}{
		VgpuTypeId: vgpuTypeId,
	}
	mock.lockVgpuTypeGetLicense.Lock()
	mock.calls.VgpuTypeGetLicense = append(mock.calls.VgpuTypeGetLicense, callInfo)
	mock.lockVgpuTypeGetLicense.Unlock()
	return mock.VgpuTypeGetLicenseFunc(vgpuTypeId)
}

// VgpuTypeGetLicenseCalls gets all the calls that were made to VgpuTypeGetLicense.
// Check the length with:
//
//	len(mockedInterface.VgpuTypeGetLicenseCalls())
func (mock *Interface) VgpuTypeGetLicenseCalls() []struct {
	VgpuTypeId nvml.VgpuTypeId
} {
	var calls []struct {
		VgpuTypeId nvml.VgpuTypeId
	}
	mock.lockVgpuTypeGetLicense.RLock()
	calls = mock.calls.VgpuTypeGetLicense
	mock.lockVgpuTypeGetLicense.RUnlock()
	return calls
}

// VgpuTypeGetMaxInstances calls VgpuTypeGetMaxInstancesFunc.
func (mock *Interface) VgpuTypeGetMaxInstances(device nvml.Device, vgpuTypeId nvml.VgpuTypeId) (int, nvml.Return) {
	if mock.VgpuTypeGetMaxInstancesFunc == nil {
		panic("Interface.VgpuTypeGetMaxInstancesFunc: method is nil but Interface.VgpuTypeGetMaxInstances was just called")
	}
	callInfo := struct {
		Device     nvml.Device
		VgpuTypeId nvml.VgpuTypeId
	}{
		Device:     device,
		VgpuTypeId: vgpuTypeId,
	}
	mock.lockVgpuTypeGetMaxInstances.Lock()
	mock.calls.VgpuTypeGetMaxInstances = append(mock.calls.VgpuTypeGetMaxInstances, callInfo)
	mock.lockVgpuTypeGetMaxInstances.Unlock()
	return mock.VgpuTypeGetMaxInstancesFunc(device, vgpuTypeId)
}

// VgpuTypeGetMaxInstancesCalls gets all the calls that were made to VgpuTypeGetMaxInstances.
// Check the length with:
//
//	len(mockedInterface.VgpuTypeGetMaxInstancesCalls())
func (mock *Interface) VgpuTypeGetMaxInstancesCalls() []struct {
	Device     nvml.Device
	VgpuTypeId nvml.VgpuTypeId
} {
	var calls []struct {
		Device     nvml.Device
		VgpuTypeId nvml.VgpuTypeId
	}
	mock.lockVgpuTypeGetMaxInstances.RLock()
	calls = mock.calls.VgpuTypeGetMaxInstances
	mock.lockVgpuTypeGetMaxInstances.RUnlock()
	return calls
}

// VgpuTypeGetMaxInstancesPerGpuInstance calls VgpuTypeGetMaxInstancesPerGpuInstanceFunc.
func (mock *Interface) VgpuTypeGetMaxInstancesPerGpuInstance(vgpuTypeMaxInstance *nvml.VgpuTypeMaxInstance) nvml.Return {
	if mock.VgpuTypeGetMaxInstancesPerGpuInstanceFunc == nil {
		panic("Interface.VgpuTypeGetMaxInstancesPerGpuInstanceFunc: method is nil but Interface.VgpuTypeGetMaxInstancesPerGpuInstance was just called")
	}
	callInfo := struct {
		VgpuTypeMaxInstance *nvml.VgpuTypeMaxInstance
	}{
		VgpuTypeMaxInstance: vgpuTypeMaxInstance,
	}
	mock.lockVgpuTypeGetMaxInstancesPerGpuInstance.Lock()
	mock.calls.VgpuTypeGetMaxInstancesPerGpuInstance = append(mock.calls.VgpuTypeGetMaxInstancesPerGpuInstance, callInfo)
	mock.lockVgpuTypeGetMaxInstancesPerGpuInstance.Unlock()
	return mock.VgpuTypeGetMaxInstancesPerGpuInstanceFunc(vgpuTypeMaxInstance)
}

// VgpuTypeGetMaxInstancesPerGpuInstanceCalls gets all the calls that were made to VgpuTypeGetMaxInstancesPerGpuInstance.
// Check the length with:
//
//	len(mockedInterface.VgpuTypeGetMaxInstancesPerGpuInstanceCalls())
func (mock *Interface) VgpuTypeGetMaxInstancesPerGpuInstanceCalls() []struct {
	VgpuTypeMaxInstance *nvml.VgpuTypeMaxInstance
} {
	var calls []struct {
		VgpuTypeMaxInstance *nvml.VgpuTypeMaxInstance
	}
	mock.lockVgpuTypeGetMaxInstancesPerGpuInstance.RLock()
	calls = mock.calls.VgpuTypeGetMaxInstancesPerGpuInstance
	mock.lockVgpuTypeGetMaxInstancesPerGpuInstance.RUnlock()
	return calls
}

// VgpuTypeGetMaxInstancesPerVm calls VgpuTypeGetMaxInstancesPerVmFunc.
func (mock *Interface) VgpuTypeGetMaxInstancesPerVm(vgpuTypeId nvml.VgpuTypeId) (int, nvml.Return) {
	if mock.VgpuTypeGetMaxInstancesPerVmFunc == nil {
		panic("Interface.VgpuTypeGetMaxInstancesPerVmFunc: method is nil but Interface.VgpuTypeGetMaxInstancesPerVm was just called")
	}
	callInfo := struct {
		VgpuTypeId nvml.VgpuTypeId
	}{
		VgpuTypeId: vgpuTypeId,
	}
	mock.lockVgpuTypeGetMaxInstancesPerVm.Lock()
	mock.calls.VgpuTypeGetMaxInstancesPerVm = append(mock.calls.VgpuTypeGetMaxInstancesPerVm, callInfo)
	mock.lockVgpuTypeGetMaxInstancesPerVm.Unlock()
	return mock.VgpuTypeGetMaxInstancesPerVmFunc(vgpuTypeId)
}

// VgpuTypeGetMaxInstancesPerVmCalls gets all the calls that were made to VgpuTypeGetMaxInstancesPerVm.
// Check the length with:
//
//	len(mockedInterface.VgpuTypeGetMaxInstancesPerVmCalls())
func (mock *Interface) VgpuTypeGetMaxInstancesPerVmCalls() []struct {
	VgpuTypeId nvml.VgpuTypeId
} {
	var calls []struct {
		VgpuTypeId nvml.VgpuTypeId
	}
	mock.lockVgpuTypeGetMaxInstancesPerVm.RLock()
	calls = mock.calls.VgpuTypeGetMaxInstancesPerVm
	mock.lockVgpuTypeGetMaxInstancesPerVm.RUnlock()
	return calls
}

// VgpuTypeGetName calls VgpuTypeGetNameFunc.
func (mock *Interface) VgpuTypeGetName(vgpuTypeId nvml.VgpuTypeId) (string, nvml.Return) {
	if mock.VgpuTypeGetNameFunc == nil {
		panic("Interface.VgpuTypeGetNameFunc: method is nil but Interface.VgpuTypeGetName was just called")
	}
	callInfo := struct {
		VgpuTypeId nvml.VgpuTypeId
	}{
		VgpuTypeId: vgpuTypeId,
	}
	mock.lockVgpuTypeGetName.Lock()
	mock.calls.VgpuTypeGetName = append(mock.calls.VgpuTypeGetName, callInfo)
	mock.lockVgpuTypeGetName.Unlock()
	return mock.VgpuTypeGetNameFunc(vgpuTypeId)
}

// VgpuTypeGetNameCalls gets all the calls that were made to VgpuTypeGetName.
// Check the length with:
//
//	len(mockedInterface.VgpuTypeGetNameCalls())
func (mock *Interface) VgpuTypeGetNameCalls() []struct {
	VgpuTypeId nvml.VgpuTypeId
} {
	var calls []struct {
		VgpuTypeId nvml.VgpuTypeId
	}
	mock.lockVgpuTypeGetName.RLock()
	calls = mock.calls.VgpuTypeGetName
	mock.lockVgpuTypeGetName.RUnlock()
	return calls
}

// VgpuTypeGetNumDisplayHeads calls VgpuTypeGetNumDisplayHeadsFunc.
func (mock *Interface) VgpuTypeGetNumDisplayHeads(vgpuTypeId nvml.VgpuTypeId) (int, nvml.Return) {
	if mock.VgpuTypeGetNumDisplayHeadsFunc == nil {
		panic("Interface.VgpuTypeGetNumDisplayHeadsFunc: method is nil but Interface.VgpuTypeGetNumDisplayHeads was just called")
	}
	callInfo := struct {
		VgpuTypeId nvml.VgpuTypeId
	}{
		VgpuTypeId: vgpuTypeId,
	}
	mock.lockVgpuTypeGetNumDisplayHeads.Lock()
	mock.calls.VgpuTypeGetNumDisplayHeads = append(mock.calls.VgpuTypeGetNumDisplayHeads, callInfo)
	mock.lockVgpuTypeGetNumDisplayHeads.Unlock()
	return mock.VgpuTypeGetNumDisplayHeadsFunc(vgpuTypeId)
}

// VgpuTypeGetNumDisplayHeadsCalls gets all the calls that were made to VgpuTypeGetNumDisplayHeads.
// Check the length with:
//
//	len(mockedInterface.VgpuTypeGetNumDisplayHeadsCalls())
func (mock *Interface) VgpuTypeGetNumDisplayHeadsCalls() []struct {
	VgpuTypeId nvml.VgpuTypeId
} {
	var calls []struct {
		VgpuTypeId nvml.VgpuTypeId
	}
	mock.lockVgpuTypeGetNumDisplayHeads.RLock()
	calls = mock.calls.VgpuTypeGetNumDisplayHeads
	mock.lockVgpuTypeGetNumDisplayHeads.RUnlock()
	return calls
}

// VgpuTypeGetResolution calls VgpuTypeGetResolutionFunc.
func (mock *Interface) VgpuTypeGetResolution(vgpuTypeId nvml.VgpuTypeId, n int) (uint32, uint32, nvml.Return) {
	if mock.VgpuTypeGetResolutionFunc == nil {
		panic("Interface.VgpuTypeGetResolutionFunc: method is nil but Interface.VgpuTypeGetResolution was just called")
	}
	callInfo := struct {
		VgpuTypeId nvml.VgpuTypeId
		N          int
	}{
		VgpuTypeId: vgpuTypeId,
		N:          n,
	}
	mock.lockVgpuTypeGetResolution.Lock()
	mock.calls.VgpuTypeGetResolution = append(mock.calls.VgpuTypeGetResolution, callInfo)
	mock.lockVgpuTypeGetResolution.Unlock()
	return mock.VgpuTypeGetResolutionFunc(vgpuTypeId, n)
}

// VgpuTypeGetResolutionCalls gets all the calls that were made to VgpuTypeGetResolution.
// Check the length with:
//
//	len(mockedInterface.VgpuTypeGetResolutionCalls())
func (mock *Interface) VgpuTypeGetResolutionCalls() []struct {
	VgpuTypeId nvml.VgpuTypeId
	N          int
} {
	var calls []struct {
		VgpuTypeId nvml.VgpuTypeId
		N          int
	}
	mock.lockVgpuTypeGetResolution.RLock()
	calls = mock.calls.VgpuTypeGetResolution
	mock.lockVgpuTypeGetResolution.RUnlock()
	return calls
}
