// 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")
//			},
//			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")
//			},
//			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")
//			},
//			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) (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")
//			},
//			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")
//			},
//			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")
//			},
//			DeviceGetDriverModelFunc: func(device nvml.Device) (nvml.DriverModel, nvml.DriverModel, nvml.Return) {
//				panic("mock out the DeviceGetDriverModel 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")
//			},
//			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")
//			},
//			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")
//			},
//			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")
//			},
//			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")
//			},
//			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")
//			},
//			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")
//			},
//			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")
//			},
//			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")
//			},
//			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")
//			},
//			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")
//			},
//			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")
//			},
//			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")
//			},
//			DeviceQueryDrainStateFunc: func(pciInfo *nvml.PciInfo) (nvml.EnableState, nvml.Return) {
//				panic("mock out the DeviceQueryDrainState 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")
//			},
//			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")
//			},
//			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")
//			},
//			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")
//			},
//			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")
//			},
//			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")
//			},
//			GpuInstanceGetInfoFunc: func(gpuInstance nvml.GpuInstance) (nvml.GpuInstanceInfo, nvml.Return) {
//				panic("mock out the GpuInstanceGetInfo 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")
//			},
//			SystemGetConfComputeCapabilitiesFunc: func() (nvml.ConfComputeSystemCaps, nvml.Return) {
//				panic("mock out the SystemGetConfComputeCapabilities 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")
//			},
//			SystemGetCudaDriverVersionFunc: func() (int, nvml.Return) {
//				panic("mock out the SystemGetCudaDriverVersion method")
//			},
//			SystemGetCudaDriverVersion_v2Func: func() (int, nvml.Return) {
//				panic("mock out the SystemGetCudaDriverVersion_v2 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")
//			},
//			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")
//			},
//			SystemSetConfComputeKeyRotationThresholdInfoFunc: func(confComputeSetKeyRotationThresholdInfo nvml.ConfComputeSetKeyRotationThresholdInfo) nvml.Return {
//				panic("mock out the SystemSetConfComputeKeyRotationThresholdInfo 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")
//			},
//			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")
//			},
//			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")
//			},
//			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)

	// 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

	// 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)

	// 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) (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)

	// 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)

	// 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)

	// DeviceGetDriverModelFunc mocks the DeviceGetDriverModel method.
	DeviceGetDriverModelFunc 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)

	// 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)

	// 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)

	// 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)

	// 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)

	// 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)

	// 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)

	// 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)

	// 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)

	// 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)

	// 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)

	// 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)

	// 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)

	// DeviceQueryDrainStateFunc mocks the DeviceQueryDrainState method.
	DeviceQueryDrainStateFunc func(pciInfo *nvml.PciInfo) (nvml.EnableState, 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

	// 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

	// 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

	// 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

	// 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

	// 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)

	// GpuInstanceGetInfoFunc mocks the GpuInstanceGetInfo method.
	GpuInstanceGetInfoFunc func(gpuInstance nvml.GpuInstance) (nvml.GpuInstanceInfo, 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

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

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

	// SystemGetConfComputeSettingsFunc mocks the SystemGetConfComputeSettings method.
	SystemGetConfComputeSettingsFunc func() (nvml.SystemConfComputeSettings, 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)

	// 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)

	// 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)

	// SystemSetConfComputeKeyRotationThresholdInfoFunc mocks the SystemSetConfComputeKeyRotationThresholdInfo method.
	SystemSetConfComputeKeyRotationThresholdInfoFunc func(confComputeSetKeyRotationThresholdInfo nvml.ConfComputeSetKeyRotationThresholdInfo) 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)

	// 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

	// 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)

	// 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
		}
		// 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
		}
		// 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
		}
		// 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
		}
		// 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
		}
		// 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
		}
		// 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
		}
		// DeviceGetDriverModel holds details about calls to the DeviceGetDriverModel method.
		DeviceGetDriverModel []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
		}
		// 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
		}
		// 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
		}
		// 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
		}
		// 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
		}
		// 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
		}
		// 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
		}
		// 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
		}
		// 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
		}
		// 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
		}
		// 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
		}
		// 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
		}
		// 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
		}
		// DeviceQueryDrainState holds details about calls to the DeviceQueryDrainState method.
		DeviceQueryDrainState []struct {
			// PciInfo is the pciInfo argument value.
			PciInfo *nvml.PciInfo
		}
		// 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
		}
		// 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
		}
		// 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
		}
		// 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
		}
		// 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
		}
		// 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
		}
		// GpuInstanceGetInfo holds details about calls to the GpuInstanceGetInfo method.
		GpuInstanceGetInfo []struct {
			// GpuInstance is the gpuInstance argument value.
			GpuInstance nvml.GpuInstance
		}
		// 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 {
		}
		// SystemGetConfComputeCapabilities holds details about calls to the SystemGetConfComputeCapabilities method.
		SystemGetConfComputeCapabilities []struct {
		}
		// SystemGetConfComputeKeyRotationThresholdInfo holds details about calls to the SystemGetConfComputeKeyRotationThresholdInfo method.
		SystemGetConfComputeKeyRotationThresholdInfo []struct {
		}
		// SystemGetConfComputeSettings holds details about calls to the SystemGetConfComputeSettings method.
		SystemGetConfComputeSettings []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 {
		}
		// 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 {
		}
		// 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
		}
		// SystemSetConfComputeKeyRotationThresholdInfo holds details about calls to the SystemSetConfComputeKeyRotationThresholdInfo method.
		SystemSetConfComputeKeyRotationThresholdInfo []struct {
			// ConfComputeSetKeyRotationThresholdInfo is the confComputeSetKeyRotationThresholdInfo argument value.
			ConfComputeSetKeyRotationThresholdInfo nvml.ConfComputeSetKeyRotationThresholdInfo
		}
		// 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
		}
		// 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
		}
		// 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
		}
		// 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
	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
	lockDeviceGetClkMonStatus                           sync.RWMutex
	lockDeviceGetClock                                  sync.RWMutex
	lockDeviceGetClockInfo                              sync.RWMutex
	lockDeviceGetComputeInstanceId                      sync.RWMutex
	lockDeviceGetComputeMode                            sync.RWMutex
	lockDeviceGetComputeRunningProcesses                sync.RWMutex
	lockDeviceGetConfComputeGpuAttestationReport        sync.RWMutex
	lockDeviceGetConfComputeGpuCertificate              sync.RWMutex
	lockDeviceGetConfComputeMemSizeInfo                 sync.RWMutex
	lockDeviceGetConfComputeProtectedMemoryUsage        sync.RWMutex
	lockDeviceGetCount                                  sync.RWMutex
	lockDeviceGetCpuAffinity                            sync.RWMutex
	lockDeviceGetCpuAffinityWithinScope                 sync.RWMutex
	lockDeviceGetCreatableVgpus                         sync.RWMutex
	lockDeviceGetCudaComputeCapability                  sync.RWMutex
	lockDeviceGetCurrPcieLinkGeneration                 sync.RWMutex
	lockDeviceGetCurrPcieLinkWidth                      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
	lockDeviceGetDriverModel                            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
	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
	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
	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
	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
	lockDeviceGetNvLinkRemoteDeviceType                 sync.RWMutex
	lockDeviceGetNvLinkRemotePciInfo                    sync.RWMutex
	lockDeviceGetNvLinkState                            sync.RWMutex
	lockDeviceGetNvLinkUtilizationControl               sync.RWMutex
	lockDeviceGetNvLinkUtilizationCounter               sync.RWMutex
	lockDeviceGetNvLinkVersion                          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
	lockDeviceGetPerformanceState                       sync.RWMutex
	lockDeviceGetPersistenceMode                        sync.RWMutex
	lockDeviceGetPgpuMetadataString                     sync.RWMutex
	lockDeviceGetPowerManagementDefaultLimit            sync.RWMutex
	lockDeviceGetPowerManagementLimit                   sync.RWMutex
	lockDeviceGetPowerManagementLimitConstraints        sync.RWMutex
	lockDeviceGetPowerManagementMode                    sync.RWMutex
	lockDeviceGetPowerSource                            sync.RWMutex
	lockDeviceGetPowerState                             sync.RWMutex
	lockDeviceGetPowerUsage                             sync.RWMutex
	lockDeviceGetProcessUtilization                     sync.RWMutex
	lockDeviceGetProcessesUtilizationInfo               sync.RWMutex
	lockDeviceGetRemappedRows                           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
	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
	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
	lockDeviceQueryDrainState                           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
	lockDeviceSetComputeMode                            sync.RWMutex
	lockDeviceSetConfComputeUnprotectedMemSize          sync.RWMutex
	lockDeviceSetCpuAffinity                            sync.RWMutex
	lockDeviceSetDefaultAutoBoostedClocksEnabled        sync.RWMutex
	lockDeviceSetDefaultFanSpeed_v2                     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
	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
	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
	lockGpuInstanceGetComputeInstanceById               sync.RWMutex
	lockGpuInstanceGetComputeInstancePossiblePlacements sync.RWMutex
	lockGpuInstanceGetComputeInstanceProfileInfo        sync.RWMutex
	lockGpuInstanceGetComputeInstanceProfileInfoV       sync.RWMutex
	lockGpuInstanceGetComputeInstanceRemainingCapacity  sync.RWMutex
	lockGpuInstanceGetComputeInstances                  sync.RWMutex
	lockGpuInstanceGetInfo                              sync.RWMutex
	lockInit                                            sync.RWMutex
	lockInitWithFlags                                   sync.RWMutex
	lockSetVgpuVersion                                  sync.RWMutex
	lockShutdown                                        sync.RWMutex
	lockSystemGetConfComputeCapabilities                sync.RWMutex
	lockSystemGetConfComputeKeyRotationThresholdInfo    sync.RWMutex
	lockSystemGetConfComputeSettings                    sync.RWMutex
	lockSystemGetCudaDriverVersion                      sync.RWMutex
	lockSystemGetCudaDriverVersion_v2                   sync.RWMutex
	lockSystemGetDriverVersion                          sync.RWMutex
	lockSystemGetHicVersion                             sync.RWMutex
	lockSystemGetNVMLVersion                            sync.RWMutex
	lockSystemGetProcessName                            sync.RWMutex
	lockSystemGetTopologyGpuSet                         sync.RWMutex
	lockSystemSetConfComputeKeyRotationThresholdInfo    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
	lockVgpuInstanceGetType                             sync.RWMutex
	lockVgpuInstanceGetUUID                             sync.RWMutex
	lockVgpuInstanceGetVmDriverVersion                  sync.RWMutex
	lockVgpuInstanceGetVmID                             sync.RWMutex
	lockVgpuInstanceSetEncoderCapacity                  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
	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
}

// 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
}

// 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
}

// 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) (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
	}{
		Device: device,
	}
	mock.lockDeviceGetConfComputeGpuAttestationReport.Lock()
	mock.calls.DeviceGetConfComputeGpuAttestationReport = append(mock.calls.DeviceGetConfComputeGpuAttestationReport, callInfo)
	mock.lockDeviceGetConfComputeGpuAttestationReport.Unlock()
	return mock.DeviceGetConfComputeGpuAttestationReportFunc(device)
}

// 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
} {
	var calls []struct {
		Device nvml.Device
	}
	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
}

// 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
}

// 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
}

// 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
}

// 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
}

// 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
}

// 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
}

// 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
}

// 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
}

// 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
}

// 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
}

// 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
}

// 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
}

// 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
}

// 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
}

// 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
}

// 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
}

// 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
}

// 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
}

// 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
}

// 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
}

// 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
}

// 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
}

// 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
}

// 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
}

// 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
}

// 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
}

// 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
}

// 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
}

// 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
}

// 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
}

// 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
}

// 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
}

// 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
}

// 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
}

// 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
}
