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

package mock

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

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

// Device is a mock implementation of nvml.Device.
//
//	func TestSomethingThatUsesDevice(t *testing.T) {
//
//		// make and configure a mocked nvml.Device
//		mockedDevice := &Device{
//			ClearAccountingPidsFunc: func() nvml.Return {
//				panic("mock out the ClearAccountingPids method")
//			},
//			ClearCpuAffinityFunc: func() nvml.Return {
//				panic("mock out the ClearCpuAffinity method")
//			},
//			ClearEccErrorCountsFunc: func(eccCounterType nvml.EccCounterType) nvml.Return {
//				panic("mock out the ClearEccErrorCounts method")
//			},
//			ClearFieldValuesFunc: func(fieldValues []nvml.FieldValue) nvml.Return {
//				panic("mock out the ClearFieldValues method")
//			},
//			CreateGpuInstanceFunc: func(gpuInstanceProfileInfo *nvml.GpuInstanceProfileInfo) (nvml.GpuInstance, nvml.Return) {
//				panic("mock out the CreateGpuInstance method")
//			},
//			CreateGpuInstanceWithPlacementFunc: func(gpuInstanceProfileInfo *nvml.GpuInstanceProfileInfo, gpuInstancePlacement *nvml.GpuInstancePlacement) (nvml.GpuInstance, nvml.Return) {
//				panic("mock out the CreateGpuInstanceWithPlacement method")
//			},
//			FreezeNvLinkUtilizationCounterFunc: func(n1 int, n2 int, enableState nvml.EnableState) nvml.Return {
//				panic("mock out the FreezeNvLinkUtilizationCounter method")
//			},
//			GetAPIRestrictionFunc: func(restrictedAPI nvml.RestrictedAPI) (nvml.EnableState, nvml.Return) {
//				panic("mock out the GetAPIRestriction method")
//			},
//			GetAccountingBufferSizeFunc: func() (int, nvml.Return) {
//				panic("mock out the GetAccountingBufferSize method")
//			},
//			GetAccountingModeFunc: func() (nvml.EnableState, nvml.Return) {
//				panic("mock out the GetAccountingMode method")
//			},
//			GetAccountingPidsFunc: func() ([]int, nvml.Return) {
//				panic("mock out the GetAccountingPids method")
//			},
//			GetAccountingStatsFunc: func(v uint32) (nvml.AccountingStats, nvml.Return) {
//				panic("mock out the GetAccountingStats method")
//			},
//			GetActiveVgpusFunc: func() ([]nvml.VgpuInstance, nvml.Return) {
//				panic("mock out the GetActiveVgpus method")
//			},
//			GetAdaptiveClockInfoStatusFunc: func() (uint32, nvml.Return) {
//				panic("mock out the GetAdaptiveClockInfoStatus method")
//			},
//			GetAddressingModeFunc: func() (nvml.DeviceAddressingMode, nvml.Return) {
//				panic("mock out the GetAddressingMode method")
//			},
//			GetApplicationsClockFunc: func(clockType nvml.ClockType) (uint32, nvml.Return) {
//				panic("mock out the GetApplicationsClock method")
//			},
//			GetArchitectureFunc: func() (nvml.DeviceArchitecture, nvml.Return) {
//				panic("mock out the GetArchitecture method")
//			},
//			GetAttributesFunc: func() (nvml.DeviceAttributes, nvml.Return) {
//				panic("mock out the GetAttributes method")
//			},
//			GetAutoBoostedClocksEnabledFunc: func() (nvml.EnableState, nvml.EnableState, nvml.Return) {
//				panic("mock out the GetAutoBoostedClocksEnabled method")
//			},
//			GetBAR1MemoryInfoFunc: func() (nvml.BAR1Memory, nvml.Return) {
//				panic("mock out the GetBAR1MemoryInfo method")
//			},
//			GetBoardIdFunc: func() (uint32, nvml.Return) {
//				panic("mock out the GetBoardId method")
//			},
//			GetBoardPartNumberFunc: func() (string, nvml.Return) {
//				panic("mock out the GetBoardPartNumber method")
//			},
//			GetBrandFunc: func() (nvml.BrandType, nvml.Return) {
//				panic("mock out the GetBrand method")
//			},
//			GetBridgeChipInfoFunc: func() (nvml.BridgeChipHierarchy, nvml.Return) {
//				panic("mock out the GetBridgeChipInfo method")
//			},
//			GetBusTypeFunc: func() (nvml.BusType, nvml.Return) {
//				panic("mock out the GetBusType method")
//			},
//			GetC2cModeInfoVFunc: func() nvml.C2cModeInfoHandler {
//				panic("mock out the GetC2cModeInfoV method")
//			},
//			GetCapabilitiesFunc: func() (nvml.DeviceCapabilities, nvml.Return) {
//				panic("mock out the GetCapabilities method")
//			},
//			GetClkMonStatusFunc: func() (nvml.ClkMonStatus, nvml.Return) {
//				panic("mock out the GetClkMonStatus method")
//			},
//			GetClockFunc: func(clockType nvml.ClockType, clockId nvml.ClockId) (uint32, nvml.Return) {
//				panic("mock out the GetClock method")
//			},
//			GetClockInfoFunc: func(clockType nvml.ClockType) (uint32, nvml.Return) {
//				panic("mock out the GetClockInfo method")
//			},
//			GetClockOffsetsFunc: func() (nvml.ClockOffset, nvml.Return) {
//				panic("mock out the GetClockOffsets method")
//			},
//			GetComputeInstanceIdFunc: func() (int, nvml.Return) {
//				panic("mock out the GetComputeInstanceId method")
//			},
//			GetComputeModeFunc: func() (nvml.ComputeMode, nvml.Return) {
//				panic("mock out the GetComputeMode method")
//			},
//			GetComputeRunningProcessesFunc: func() ([]nvml.ProcessInfo, nvml.Return) {
//				panic("mock out the GetComputeRunningProcesses method")
//			},
//			GetConfComputeGpuAttestationReportFunc: func(confComputeGpuAttestationReport *nvml.ConfComputeGpuAttestationReport) nvml.Return {
//				panic("mock out the GetConfComputeGpuAttestationReport method")
//			},
//			GetConfComputeGpuCertificateFunc: func() (nvml.ConfComputeGpuCertificate, nvml.Return) {
//				panic("mock out the GetConfComputeGpuCertificate method")
//			},
//			GetConfComputeMemSizeInfoFunc: func() (nvml.ConfComputeMemSizeInfo, nvml.Return) {
//				panic("mock out the GetConfComputeMemSizeInfo method")
//			},
//			GetConfComputeProtectedMemoryUsageFunc: func() (nvml.Memory, nvml.Return) {
//				panic("mock out the GetConfComputeProtectedMemoryUsage method")
//			},
//			GetCoolerInfoFunc: func() (nvml.CoolerInfo, nvml.Return) {
//				panic("mock out the GetCoolerInfo method")
//			},
//			GetCpuAffinityFunc: func(n int) ([]uint, nvml.Return) {
//				panic("mock out the GetCpuAffinity method")
//			},
//			GetCpuAffinityWithinScopeFunc: func(n int, affinityScope nvml.AffinityScope) ([]uint, nvml.Return) {
//				panic("mock out the GetCpuAffinityWithinScope method")
//			},
//			GetCreatableVgpusFunc: func() ([]nvml.VgpuTypeId, nvml.Return) {
//				panic("mock out the GetCreatableVgpus method")
//			},
//			GetCudaComputeCapabilityFunc: func() (int, int, nvml.Return) {
//				panic("mock out the GetCudaComputeCapability method")
//			},
//			GetCurrPcieLinkGenerationFunc: func() (int, nvml.Return) {
//				panic("mock out the GetCurrPcieLinkGeneration method")
//			},
//			GetCurrPcieLinkWidthFunc: func() (int, nvml.Return) {
//				panic("mock out the GetCurrPcieLinkWidth method")
//			},
//			GetCurrentClockFreqsFunc: func() (nvml.DeviceCurrentClockFreqs, nvml.Return) {
//				panic("mock out the GetCurrentClockFreqs method")
//			},
//			GetCurrentClocksEventReasonsFunc: func() (uint64, nvml.Return) {
//				panic("mock out the GetCurrentClocksEventReasons method")
//			},
//			GetCurrentClocksThrottleReasonsFunc: func() (uint64, nvml.Return) {
//				panic("mock out the GetCurrentClocksThrottleReasons method")
//			},
//			GetDecoderUtilizationFunc: func() (uint32, uint32, nvml.Return) {
//				panic("mock out the GetDecoderUtilization method")
//			},
//			GetDefaultApplicationsClockFunc: func(clockType nvml.ClockType) (uint32, nvml.Return) {
//				panic("mock out the GetDefaultApplicationsClock method")
//			},
//			GetDefaultEccModeFunc: func() (nvml.EnableState, nvml.Return) {
//				panic("mock out the GetDefaultEccMode method")
//			},
//			GetDetailedEccErrorsFunc: func(memoryErrorType nvml.MemoryErrorType, eccCounterType nvml.EccCounterType) (nvml.EccErrorCounts, nvml.Return) {
//				panic("mock out the GetDetailedEccErrors method")
//			},
//			GetDeviceHandleFromMigDeviceHandleFunc: func() (nvml.Device, nvml.Return) {
//				panic("mock out the GetDeviceHandleFromMigDeviceHandle method")
//			},
//			GetDisplayActiveFunc: func() (nvml.EnableState, nvml.Return) {
//				panic("mock out the GetDisplayActive method")
//			},
//			GetDisplayModeFunc: func() (nvml.EnableState, nvml.Return) {
//				panic("mock out the GetDisplayMode method")
//			},
//			GetDramEncryptionModeFunc: func() (nvml.DramEncryptionInfo, nvml.DramEncryptionInfo, nvml.Return) {
//				panic("mock out the GetDramEncryptionMode method")
//			},
//			GetDriverModelFunc: func() (nvml.DriverModel, nvml.DriverModel, nvml.Return) {
//				panic("mock out the GetDriverModel method")
//			},
//			GetDriverModel_v2Func: func() (nvml.DriverModel, nvml.DriverModel, nvml.Return) {
//				panic("mock out the GetDriverModel_v2 method")
//			},
//			GetDynamicPstatesInfoFunc: func() (nvml.GpuDynamicPstatesInfo, nvml.Return) {
//				panic("mock out the GetDynamicPstatesInfo method")
//			},
//			GetEccModeFunc: func() (nvml.EnableState, nvml.EnableState, nvml.Return) {
//				panic("mock out the GetEccMode method")
//			},
//			GetEncoderCapacityFunc: func(encoderType nvml.EncoderType) (int, nvml.Return) {
//				panic("mock out the GetEncoderCapacity method")
//			},
//			GetEncoderSessionsFunc: func() ([]nvml.EncoderSessionInfo, nvml.Return) {
//				panic("mock out the GetEncoderSessions method")
//			},
//			GetEncoderStatsFunc: func() (int, uint32, uint32, nvml.Return) {
//				panic("mock out the GetEncoderStats method")
//			},
//			GetEncoderUtilizationFunc: func() (uint32, uint32, nvml.Return) {
//				panic("mock out the GetEncoderUtilization method")
//			},
//			GetEnforcedPowerLimitFunc: func() (uint32, nvml.Return) {
//				panic("mock out the GetEnforcedPowerLimit method")
//			},
//			GetFBCSessionsFunc: func() ([]nvml.FBCSessionInfo, nvml.Return) {
//				panic("mock out the GetFBCSessions method")
//			},
//			GetFBCStatsFunc: func() (nvml.FBCStats, nvml.Return) {
//				panic("mock out the GetFBCStats method")
//			},
//			GetFanControlPolicy_v2Func: func(n int) (nvml.FanControlPolicy, nvml.Return) {
//				panic("mock out the GetFanControlPolicy_v2 method")
//			},
//			GetFanSpeedFunc: func() (uint32, nvml.Return) {
//				panic("mock out the GetFanSpeed method")
//			},
//			GetFanSpeedRPMFunc: func() (nvml.FanSpeedInfo, nvml.Return) {
//				panic("mock out the GetFanSpeedRPM method")
//			},
//			GetFanSpeed_v2Func: func(n int) (uint32, nvml.Return) {
//				panic("mock out the GetFanSpeed_v2 method")
//			},
//			GetFieldValuesFunc: func(fieldValues []nvml.FieldValue) nvml.Return {
//				panic("mock out the GetFieldValues method")
//			},
//			GetGpcClkMinMaxVfOffsetFunc: func() (int, int, nvml.Return) {
//				panic("mock out the GetGpcClkMinMaxVfOffset method")
//			},
//			GetGpcClkVfOffsetFunc: func() (int, nvml.Return) {
//				panic("mock out the GetGpcClkVfOffset method")
//			},
//			GetGpuFabricInfoFunc: func() (nvml.GpuFabricInfo, nvml.Return) {
//				panic("mock out the GetGpuFabricInfo method")
//			},
//			GetGpuFabricInfoVFunc: func() nvml.GpuFabricInfoHandler {
//				panic("mock out the GetGpuFabricInfoV method")
//			},
//			GetGpuInstanceByIdFunc: func(n int) (nvml.GpuInstance, nvml.Return) {
//				panic("mock out the GetGpuInstanceById method")
//			},
//			GetGpuInstanceIdFunc: func() (int, nvml.Return) {
//				panic("mock out the GetGpuInstanceId method")
//			},
//			GetGpuInstancePossiblePlacementsFunc: func(gpuInstanceProfileInfo *nvml.GpuInstanceProfileInfo) ([]nvml.GpuInstancePlacement, nvml.Return) {
//				panic("mock out the GetGpuInstancePossiblePlacements method")
//			},
//			GetGpuInstanceProfileInfoFunc: func(n int) (nvml.GpuInstanceProfileInfo, nvml.Return) {
//				panic("mock out the GetGpuInstanceProfileInfo method")
//			},
//			GetGpuInstanceProfileInfoByIdVFunc: func(n int) nvml.GpuInstanceProfileInfoByIdHandler {
//				panic("mock out the GetGpuInstanceProfileInfoByIdV method")
//			},
//			GetGpuInstanceProfileInfoVFunc: func(n int) nvml.GpuInstanceProfileInfoHandler {
//				panic("mock out the GetGpuInstanceProfileInfoV method")
//			},
//			GetGpuInstanceRemainingCapacityFunc: func(gpuInstanceProfileInfo *nvml.GpuInstanceProfileInfo) (int, nvml.Return) {
//				panic("mock out the GetGpuInstanceRemainingCapacity method")
//			},
//			GetGpuInstancesFunc: func(gpuInstanceProfileInfo *nvml.GpuInstanceProfileInfo) ([]nvml.GpuInstance, nvml.Return) {
//				panic("mock out the GetGpuInstances method")
//			},
//			GetGpuMaxPcieLinkGenerationFunc: func() (int, nvml.Return) {
//				panic("mock out the GetGpuMaxPcieLinkGeneration method")
//			},
//			GetGpuOperationModeFunc: func() (nvml.GpuOperationMode, nvml.GpuOperationMode, nvml.Return) {
//				panic("mock out the GetGpuOperationMode method")
//			},
//			GetGraphicsRunningProcessesFunc: func() ([]nvml.ProcessInfo, nvml.Return) {
//				panic("mock out the GetGraphicsRunningProcesses method")
//			},
//			GetGridLicensableFeaturesFunc: func() (nvml.GridLicensableFeatures, nvml.Return) {
//				panic("mock out the GetGridLicensableFeatures method")
//			},
//			GetGspFirmwareModeFunc: func() (bool, bool, nvml.Return) {
//				panic("mock out the GetGspFirmwareMode method")
//			},
//			GetGspFirmwareVersionFunc: func() (string, nvml.Return) {
//				panic("mock out the GetGspFirmwareVersion method")
//			},
//			GetHostVgpuModeFunc: func() (nvml.HostVgpuMode, nvml.Return) {
//				panic("mock out the GetHostVgpuMode method")
//			},
//			GetIndexFunc: func() (int, nvml.Return) {
//				panic("mock out the GetIndex method")
//			},
//			GetInforomConfigurationChecksumFunc: func() (uint32, nvml.Return) {
//				panic("mock out the GetInforomConfigurationChecksum method")
//			},
//			GetInforomImageVersionFunc: func() (string, nvml.Return) {
//				panic("mock out the GetInforomImageVersion method")
//			},
//			GetInforomVersionFunc: func(inforomObject nvml.InforomObject) (string, nvml.Return) {
//				panic("mock out the GetInforomVersion method")
//			},
//			GetIrqNumFunc: func() (int, nvml.Return) {
//				panic("mock out the GetIrqNum method")
//			},
//			GetJpgUtilizationFunc: func() (uint32, uint32, nvml.Return) {
//				panic("mock out the GetJpgUtilization method")
//			},
//			GetLastBBXFlushTimeFunc: func() (uint64, uint, nvml.Return) {
//				panic("mock out the GetLastBBXFlushTime method")
//			},
//			GetMPSComputeRunningProcessesFunc: func() ([]nvml.ProcessInfo, nvml.Return) {
//				panic("mock out the GetMPSComputeRunningProcesses method")
//			},
//			GetMarginTemperatureFunc: func() (nvml.MarginTemperature, nvml.Return) {
//				panic("mock out the GetMarginTemperature method")
//			},
//			GetMaxClockInfoFunc: func(clockType nvml.ClockType) (uint32, nvml.Return) {
//				panic("mock out the GetMaxClockInfo method")
//			},
//			GetMaxCustomerBoostClockFunc: func(clockType nvml.ClockType) (uint32, nvml.Return) {
//				panic("mock out the GetMaxCustomerBoostClock method")
//			},
//			GetMaxMigDeviceCountFunc: func() (int, nvml.Return) {
//				panic("mock out the GetMaxMigDeviceCount method")
//			},
//			GetMaxPcieLinkGenerationFunc: func() (int, nvml.Return) {
//				panic("mock out the GetMaxPcieLinkGeneration method")
//			},
//			GetMaxPcieLinkWidthFunc: func() (int, nvml.Return) {
//				panic("mock out the GetMaxPcieLinkWidth method")
//			},
//			GetMemClkMinMaxVfOffsetFunc: func() (int, int, nvml.Return) {
//				panic("mock out the GetMemClkMinMaxVfOffset method")
//			},
//			GetMemClkVfOffsetFunc: func() (int, nvml.Return) {
//				panic("mock out the GetMemClkVfOffset method")
//			},
//			GetMemoryAffinityFunc: func(n int, affinityScope nvml.AffinityScope) ([]uint, nvml.Return) {
//				panic("mock out the GetMemoryAffinity method")
//			},
//			GetMemoryBusWidthFunc: func() (uint32, nvml.Return) {
//				panic("mock out the GetMemoryBusWidth method")
//			},
//			GetMemoryErrorCounterFunc: func(memoryErrorType nvml.MemoryErrorType, eccCounterType nvml.EccCounterType, memoryLocation nvml.MemoryLocation) (uint64, nvml.Return) {
//				panic("mock out the GetMemoryErrorCounter method")
//			},
//			GetMemoryInfoFunc: func() (nvml.Memory, nvml.Return) {
//				panic("mock out the GetMemoryInfo method")
//			},
//			GetMemoryInfo_v2Func: func() (nvml.Memory_v2, nvml.Return) {
//				panic("mock out the GetMemoryInfo_v2 method")
//			},
//			GetMigDeviceHandleByIndexFunc: func(n int) (nvml.Device, nvml.Return) {
//				panic("mock out the GetMigDeviceHandleByIndex method")
//			},
//			GetMigModeFunc: func() (int, int, nvml.Return) {
//				panic("mock out the GetMigMode method")
//			},
//			GetMinMaxClockOfPStateFunc: func(clockType nvml.ClockType, pstates nvml.Pstates) (uint32, uint32, nvml.Return) {
//				panic("mock out the GetMinMaxClockOfPState method")
//			},
//			GetMinMaxFanSpeedFunc: func() (int, int, nvml.Return) {
//				panic("mock out the GetMinMaxFanSpeed method")
//			},
//			GetMinorNumberFunc: func() (int, nvml.Return) {
//				panic("mock out the GetMinorNumber method")
//			},
//			GetModuleIdFunc: func() (int, nvml.Return) {
//				panic("mock out the GetModuleId method")
//			},
//			GetMultiGpuBoardFunc: func() (int, nvml.Return) {
//				panic("mock out the GetMultiGpuBoard method")
//			},
//			GetNameFunc: func() (string, nvml.Return) {
//				panic("mock out the GetName method")
//			},
//			GetNumFansFunc: func() (int, nvml.Return) {
//				panic("mock out the GetNumFans method")
//			},
//			GetNumGpuCoresFunc: func() (int, nvml.Return) {
//				panic("mock out the GetNumGpuCores method")
//			},
//			GetNumaNodeIdFunc: func() (int, nvml.Return) {
//				panic("mock out the GetNumaNodeId method")
//			},
//			GetNvLinkCapabilityFunc: func(n int, nvLinkCapability nvml.NvLinkCapability) (uint32, nvml.Return) {
//				panic("mock out the GetNvLinkCapability method")
//			},
//			GetNvLinkErrorCounterFunc: func(n int, nvLinkErrorCounter nvml.NvLinkErrorCounter) (uint64, nvml.Return) {
//				panic("mock out the GetNvLinkErrorCounter method")
//			},
//			GetNvLinkInfoFunc: func() nvml.NvLinkInfoHandler {
//				panic("mock out the GetNvLinkInfo method")
//			},
//			GetNvLinkRemoteDeviceTypeFunc: func(n int) (nvml.IntNvLinkDeviceType, nvml.Return) {
//				panic("mock out the GetNvLinkRemoteDeviceType method")
//			},
//			GetNvLinkRemotePciInfoFunc: func(n int) (nvml.PciInfo, nvml.Return) {
//				panic("mock out the GetNvLinkRemotePciInfo method")
//			},
//			GetNvLinkStateFunc: func(n int) (nvml.EnableState, nvml.Return) {
//				panic("mock out the GetNvLinkState method")
//			},
//			GetNvLinkUtilizationControlFunc: func(n1 int, n2 int) (nvml.NvLinkUtilizationControl, nvml.Return) {
//				panic("mock out the GetNvLinkUtilizationControl method")
//			},
//			GetNvLinkUtilizationCounterFunc: func(n1 int, n2 int) (uint64, uint64, nvml.Return) {
//				panic("mock out the GetNvLinkUtilizationCounter method")
//			},
//			GetNvLinkVersionFunc: func(n int) (uint32, nvml.Return) {
//				panic("mock out the GetNvLinkVersion method")
//			},
//			GetNvlinkBwModeFunc: func() (nvml.NvlinkGetBwMode, nvml.Return) {
//				panic("mock out the GetNvlinkBwMode method")
//			},
//			GetNvlinkSupportedBwModesFunc: func() (nvml.NvlinkSupportedBwModes, nvml.Return) {
//				panic("mock out the GetNvlinkSupportedBwModes method")
//			},
//			GetOfaUtilizationFunc: func() (uint32, uint32, nvml.Return) {
//				panic("mock out the GetOfaUtilization method")
//			},
//			GetP2PStatusFunc: func(device nvml.Device, gpuP2PCapsIndex nvml.GpuP2PCapsIndex) (nvml.GpuP2PStatus, nvml.Return) {
//				panic("mock out the GetP2PStatus method")
//			},
//			GetPciInfoFunc: func() (nvml.PciInfo, nvml.Return) {
//				panic("mock out the GetPciInfo method")
//			},
//			GetPciInfoExtFunc: func() (nvml.PciInfoExt, nvml.Return) {
//				panic("mock out the GetPciInfoExt method")
//			},
//			GetPcieLinkMaxSpeedFunc: func() (uint32, nvml.Return) {
//				panic("mock out the GetPcieLinkMaxSpeed method")
//			},
//			GetPcieReplayCounterFunc: func() (int, nvml.Return) {
//				panic("mock out the GetPcieReplayCounter method")
//			},
//			GetPcieSpeedFunc: func() (int, nvml.Return) {
//				panic("mock out the GetPcieSpeed method")
//			},
//			GetPcieThroughputFunc: func(pcieUtilCounter nvml.PcieUtilCounter) (uint32, nvml.Return) {
//				panic("mock out the GetPcieThroughput method")
//			},
//			GetPdiFunc: func() (nvml.Pdi, nvml.Return) {
//				panic("mock out the GetPdi method")
//			},
//			GetPerformanceModesFunc: func() (nvml.DevicePerfModes, nvml.Return) {
//				panic("mock out the GetPerformanceModes method")
//			},
//			GetPerformanceStateFunc: func() (nvml.Pstates, nvml.Return) {
//				panic("mock out the GetPerformanceState method")
//			},
//			GetPersistenceModeFunc: func() (nvml.EnableState, nvml.Return) {
//				panic("mock out the GetPersistenceMode method")
//			},
//			GetPgpuMetadataStringFunc: func() (string, nvml.Return) {
//				panic("mock out the GetPgpuMetadataString method")
//			},
//			GetPlatformInfoFunc: func() (nvml.PlatformInfo, nvml.Return) {
//				panic("mock out the GetPlatformInfo method")
//			},
//			GetPowerManagementDefaultLimitFunc: func() (uint32, nvml.Return) {
//				panic("mock out the GetPowerManagementDefaultLimit method")
//			},
//			GetPowerManagementLimitFunc: func() (uint32, nvml.Return) {
//				panic("mock out the GetPowerManagementLimit method")
//			},
//			GetPowerManagementLimitConstraintsFunc: func() (uint32, uint32, nvml.Return) {
//				panic("mock out the GetPowerManagementLimitConstraints method")
//			},
//			GetPowerManagementModeFunc: func() (nvml.EnableState, nvml.Return) {
//				panic("mock out the GetPowerManagementMode method")
//			},
//			GetPowerMizerMode_v1Func: func() (nvml.DevicePowerMizerModes_v1, nvml.Return) {
//				panic("mock out the GetPowerMizerMode_v1 method")
//			},
//			GetPowerSourceFunc: func() (nvml.PowerSource, nvml.Return) {
//				panic("mock out the GetPowerSource method")
//			},
//			GetPowerStateFunc: func() (nvml.Pstates, nvml.Return) {
//				panic("mock out the GetPowerState method")
//			},
//			GetPowerUsageFunc: func() (uint32, nvml.Return) {
//				panic("mock out the GetPowerUsage method")
//			},
//			GetProcessUtilizationFunc: func(v uint64) ([]nvml.ProcessUtilizationSample, nvml.Return) {
//				panic("mock out the GetProcessUtilization method")
//			},
//			GetProcessesUtilizationInfoFunc: func() (nvml.ProcessesUtilizationInfo, nvml.Return) {
//				panic("mock out the GetProcessesUtilizationInfo method")
//			},
//			GetRemappedRowsFunc: func() (int, int, bool, bool, nvml.Return) {
//				panic("mock out the GetRemappedRows method")
//			},
//			GetRepairStatusFunc: func() (nvml.RepairStatus, nvml.Return) {
//				panic("mock out the GetRepairStatus method")
//			},
//			GetRetiredPagesFunc: func(pageRetirementCause nvml.PageRetirementCause) ([]uint64, nvml.Return) {
//				panic("mock out the GetRetiredPages method")
//			},
//			GetRetiredPagesPendingStatusFunc: func() (nvml.EnableState, nvml.Return) {
//				panic("mock out the GetRetiredPagesPendingStatus method")
//			},
//			GetRetiredPages_v2Func: func(pageRetirementCause nvml.PageRetirementCause) ([]uint64, []uint64, nvml.Return) {
//				panic("mock out the GetRetiredPages_v2 method")
//			},
//			GetRowRemapperHistogramFunc: func() (nvml.RowRemapperHistogramValues, nvml.Return) {
//				panic("mock out the GetRowRemapperHistogram method")
//			},
//			GetRunningProcessDetailListFunc: func() (nvml.ProcessDetailList, nvml.Return) {
//				panic("mock out the GetRunningProcessDetailList method")
//			},
//			GetSamplesFunc: func(samplingType nvml.SamplingType, v uint64) (nvml.ValueType, []nvml.Sample, nvml.Return) {
//				panic("mock out the GetSamples method")
//			},
//			GetSerialFunc: func() (string, nvml.Return) {
//				panic("mock out the GetSerial method")
//			},
//			GetSramEccErrorStatusFunc: func() (nvml.EccSramErrorStatus, nvml.Return) {
//				panic("mock out the GetSramEccErrorStatus method")
//			},
//			GetSramUniqueUncorrectedEccErrorCountsFunc: func(eccSramUniqueUncorrectedErrorCounts *nvml.EccSramUniqueUncorrectedErrorCounts) nvml.Return {
//				panic("mock out the GetSramUniqueUncorrectedEccErrorCounts method")
//			},
//			GetSupportedClocksEventReasonsFunc: func() (uint64, nvml.Return) {
//				panic("mock out the GetSupportedClocksEventReasons method")
//			},
//			GetSupportedClocksThrottleReasonsFunc: func() (uint64, nvml.Return) {
//				panic("mock out the GetSupportedClocksThrottleReasons method")
//			},
//			GetSupportedEventTypesFunc: func() (uint64, nvml.Return) {
//				panic("mock out the GetSupportedEventTypes method")
//			},
//			GetSupportedGraphicsClocksFunc: func(n int) (int, uint32, nvml.Return) {
//				panic("mock out the GetSupportedGraphicsClocks method")
//			},
//			GetSupportedMemoryClocksFunc: func() (int, uint32, nvml.Return) {
//				panic("mock out the GetSupportedMemoryClocks method")
//			},
//			GetSupportedPerformanceStatesFunc: func() ([]nvml.Pstates, nvml.Return) {
//				panic("mock out the GetSupportedPerformanceStates method")
//			},
//			GetSupportedVgpusFunc: func() ([]nvml.VgpuTypeId, nvml.Return) {
//				panic("mock out the GetSupportedVgpus method")
//			},
//			GetTargetFanSpeedFunc: func(n int) (int, nvml.Return) {
//				panic("mock out the GetTargetFanSpeed method")
//			},
//			GetTemperatureFunc: func(temperatureSensors nvml.TemperatureSensors) (uint32, nvml.Return) {
//				panic("mock out the GetTemperature method")
//			},
//			GetTemperatureThresholdFunc: func(temperatureThresholds nvml.TemperatureThresholds) (uint32, nvml.Return) {
//				panic("mock out the GetTemperatureThreshold method")
//			},
//			GetTemperatureVFunc: func() nvml.TemperatureHandler {
//				panic("mock out the GetTemperatureV method")
//			},
//			GetThermalSettingsFunc: func(v uint32) (nvml.GpuThermalSettings, nvml.Return) {
//				panic("mock out the GetThermalSettings method")
//			},
//			GetTopologyCommonAncestorFunc: func(device nvml.Device) (nvml.GpuTopologyLevel, nvml.Return) {
//				panic("mock out the GetTopologyCommonAncestor method")
//			},
//			GetTopologyNearestGpusFunc: func(gpuTopologyLevel nvml.GpuTopologyLevel) ([]nvml.Device, nvml.Return) {
//				panic("mock out the GetTopologyNearestGpus method")
//			},
//			GetTotalEccErrorsFunc: func(memoryErrorType nvml.MemoryErrorType, eccCounterType nvml.EccCounterType) (uint64, nvml.Return) {
//				panic("mock out the GetTotalEccErrors method")
//			},
//			GetTotalEnergyConsumptionFunc: func() (uint64, nvml.Return) {
//				panic("mock out the GetTotalEnergyConsumption method")
//			},
//			GetUUIDFunc: func() (string, nvml.Return) {
//				panic("mock out the GetUUID method")
//			},
//			GetUtilizationRatesFunc: func() (nvml.Utilization, nvml.Return) {
//				panic("mock out the GetUtilizationRates method")
//			},
//			GetVbiosVersionFunc: func() (string, nvml.Return) {
//				panic("mock out the GetVbiosVersion method")
//			},
//			GetVgpuCapabilitiesFunc: func(deviceVgpuCapability nvml.DeviceVgpuCapability) (bool, nvml.Return) {
//				panic("mock out the GetVgpuCapabilities method")
//			},
//			GetVgpuHeterogeneousModeFunc: func() (nvml.VgpuHeterogeneousMode, nvml.Return) {
//				panic("mock out the GetVgpuHeterogeneousMode method")
//			},
//			GetVgpuInstancesUtilizationInfoFunc: func() (nvml.VgpuInstancesUtilizationInfo, nvml.Return) {
//				panic("mock out the GetVgpuInstancesUtilizationInfo method")
//			},
//			GetVgpuMetadataFunc: func() (nvml.VgpuPgpuMetadata, nvml.Return) {
//				panic("mock out the GetVgpuMetadata method")
//			},
//			GetVgpuProcessUtilizationFunc: func(v uint64) ([]nvml.VgpuProcessUtilizationSample, nvml.Return) {
//				panic("mock out the GetVgpuProcessUtilization method")
//			},
//			GetVgpuProcessesUtilizationInfoFunc: func() (nvml.VgpuProcessesUtilizationInfo, nvml.Return) {
//				panic("mock out the GetVgpuProcessesUtilizationInfo method")
//			},
//			GetVgpuSchedulerCapabilitiesFunc: func() (nvml.VgpuSchedulerCapabilities, nvml.Return) {
//				panic("mock out the GetVgpuSchedulerCapabilities method")
//			},
//			GetVgpuSchedulerLogFunc: func() (nvml.VgpuSchedulerLog, nvml.Return) {
//				panic("mock out the GetVgpuSchedulerLog method")
//			},
//			GetVgpuSchedulerStateFunc: func() (nvml.VgpuSchedulerGetState, nvml.Return) {
//				panic("mock out the GetVgpuSchedulerState method")
//			},
//			GetVgpuTypeCreatablePlacementsFunc: func(vgpuTypeId nvml.VgpuTypeId) (nvml.VgpuPlacementList, nvml.Return) {
//				panic("mock out the GetVgpuTypeCreatablePlacements method")
//			},
//			GetVgpuTypeSupportedPlacementsFunc: func(vgpuTypeId nvml.VgpuTypeId) (nvml.VgpuPlacementList, nvml.Return) {
//				panic("mock out the GetVgpuTypeSupportedPlacements method")
//			},
//			GetVgpuUtilizationFunc: func(v uint64) (nvml.ValueType, []nvml.VgpuInstanceUtilizationSample, nvml.Return) {
//				panic("mock out the GetVgpuUtilization method")
//			},
//			GetViolationStatusFunc: func(perfPolicyType nvml.PerfPolicyType) (nvml.ViolationTime, nvml.Return) {
//				panic("mock out the GetViolationStatus method")
//			},
//			GetVirtualizationModeFunc: func() (nvml.GpuVirtualizationMode, nvml.Return) {
//				panic("mock out the GetVirtualizationMode method")
//			},
//			GpmMigSampleGetFunc: func(n int, gpmSample nvml.GpmSample) nvml.Return {
//				panic("mock out the GpmMigSampleGet method")
//			},
//			GpmQueryDeviceSupportFunc: func() (nvml.GpmSupport, nvml.Return) {
//				panic("mock out the GpmQueryDeviceSupport method")
//			},
//			GpmQueryDeviceSupportVFunc: func() nvml.GpmSupportV {
//				panic("mock out the GpmQueryDeviceSupportV method")
//			},
//			GpmQueryIfStreamingEnabledFunc: func() (uint32, nvml.Return) {
//				panic("mock out the GpmQueryIfStreamingEnabled method")
//			},
//			GpmSampleGetFunc: func(gpmSample nvml.GpmSample) nvml.Return {
//				panic("mock out the GpmSampleGet method")
//			},
//			GpmSetStreamingEnabledFunc: func(v uint32) nvml.Return {
//				panic("mock out the GpmSetStreamingEnabled method")
//			},
//			IsMigDeviceHandleFunc: func() (bool, nvml.Return) {
//				panic("mock out the IsMigDeviceHandle method")
//			},
//			OnSameBoardFunc: func(device nvml.Device) (int, nvml.Return) {
//				panic("mock out the OnSameBoard method")
//			},
//			PowerSmoothingActivatePresetProfileFunc: func(powerSmoothingProfile *nvml.PowerSmoothingProfile) nvml.Return {
//				panic("mock out the PowerSmoothingActivatePresetProfile method")
//			},
//			PowerSmoothingSetStateFunc: func(powerSmoothingState *nvml.PowerSmoothingState) nvml.Return {
//				panic("mock out the PowerSmoothingSetState method")
//			},
//			PowerSmoothingUpdatePresetProfileParamFunc: func(powerSmoothingProfile *nvml.PowerSmoothingProfile) nvml.Return {
//				panic("mock out the PowerSmoothingUpdatePresetProfileParam method")
//			},
//			ReadWritePRM_v1Func: func(pRMTLV_v1 *nvml.PRMTLV_v1) nvml.Return {
//				panic("mock out the ReadWritePRM_v1 method")
//			},
//			RegisterEventsFunc: func(v uint64, eventSet nvml.EventSet) nvml.Return {
//				panic("mock out the RegisterEvents method")
//			},
//			ResetApplicationsClocksFunc: func() nvml.Return {
//				panic("mock out the ResetApplicationsClocks method")
//			},
//			ResetGpuLockedClocksFunc: func() nvml.Return {
//				panic("mock out the ResetGpuLockedClocks method")
//			},
//			ResetMemoryLockedClocksFunc: func() nvml.Return {
//				panic("mock out the ResetMemoryLockedClocks method")
//			},
//			ResetNvLinkErrorCountersFunc: func(n int) nvml.Return {
//				panic("mock out the ResetNvLinkErrorCounters method")
//			},
//			ResetNvLinkUtilizationCounterFunc: func(n1 int, n2 int) nvml.Return {
//				panic("mock out the ResetNvLinkUtilizationCounter method")
//			},
//			SetAPIRestrictionFunc: func(restrictedAPI nvml.RestrictedAPI, enableState nvml.EnableState) nvml.Return {
//				panic("mock out the SetAPIRestriction method")
//			},
//			SetAccountingModeFunc: func(enableState nvml.EnableState) nvml.Return {
//				panic("mock out the SetAccountingMode method")
//			},
//			SetApplicationsClocksFunc: func(v1 uint32, v2 uint32) nvml.Return {
//				panic("mock out the SetApplicationsClocks method")
//			},
//			SetAutoBoostedClocksEnabledFunc: func(enableState nvml.EnableState) nvml.Return {
//				panic("mock out the SetAutoBoostedClocksEnabled method")
//			},
//			SetClockOffsetsFunc: func(clockOffset nvml.ClockOffset) nvml.Return {
//				panic("mock out the SetClockOffsets method")
//			},
//			SetComputeModeFunc: func(computeMode nvml.ComputeMode) nvml.Return {
//				panic("mock out the SetComputeMode method")
//			},
//			SetConfComputeUnprotectedMemSizeFunc: func(v uint64) nvml.Return {
//				panic("mock out the SetConfComputeUnprotectedMemSize method")
//			},
//			SetCpuAffinityFunc: func() nvml.Return {
//				panic("mock out the SetCpuAffinity method")
//			},
//			SetDefaultAutoBoostedClocksEnabledFunc: func(enableState nvml.EnableState, v uint32) nvml.Return {
//				panic("mock out the SetDefaultAutoBoostedClocksEnabled method")
//			},
//			SetDefaultFanSpeed_v2Func: func(n int) nvml.Return {
//				panic("mock out the SetDefaultFanSpeed_v2 method")
//			},
//			SetDramEncryptionModeFunc: func(dramEncryptionInfo *nvml.DramEncryptionInfo) nvml.Return {
//				panic("mock out the SetDramEncryptionMode method")
//			},
//			SetDriverModelFunc: func(driverModel nvml.DriverModel, v uint32) nvml.Return {
//				panic("mock out the SetDriverModel method")
//			},
//			SetEccModeFunc: func(enableState nvml.EnableState) nvml.Return {
//				panic("mock out the SetEccMode method")
//			},
//			SetFanControlPolicyFunc: func(n int, fanControlPolicy nvml.FanControlPolicy) nvml.Return {
//				panic("mock out the SetFanControlPolicy method")
//			},
//			SetFanSpeed_v2Func: func(n1 int, n2 int) nvml.Return {
//				panic("mock out the SetFanSpeed_v2 method")
//			},
//			SetGpcClkVfOffsetFunc: func(n int) nvml.Return {
//				panic("mock out the SetGpcClkVfOffset method")
//			},
//			SetGpuLockedClocksFunc: func(v1 uint32, v2 uint32) nvml.Return {
//				panic("mock out the SetGpuLockedClocks method")
//			},
//			SetGpuOperationModeFunc: func(gpuOperationMode nvml.GpuOperationMode) nvml.Return {
//				panic("mock out the SetGpuOperationMode method")
//			},
//			SetMemClkVfOffsetFunc: func(n int) nvml.Return {
//				panic("mock out the SetMemClkVfOffset method")
//			},
//			SetMemoryLockedClocksFunc: func(v1 uint32, v2 uint32) nvml.Return {
//				panic("mock out the SetMemoryLockedClocks method")
//			},
//			SetMigModeFunc: func(n int) (nvml.Return, nvml.Return) {
//				panic("mock out the SetMigMode method")
//			},
//			SetNvLinkDeviceLowPowerThresholdFunc: func(nvLinkPowerThres *nvml.NvLinkPowerThres) nvml.Return {
//				panic("mock out the SetNvLinkDeviceLowPowerThreshold method")
//			},
//			SetNvLinkUtilizationControlFunc: func(n1 int, n2 int, nvLinkUtilizationControl *nvml.NvLinkUtilizationControl, b bool) nvml.Return {
//				panic("mock out the SetNvLinkUtilizationControl method")
//			},
//			SetNvlinkBwModeFunc: func(nvlinkSetBwMode *nvml.NvlinkSetBwMode) nvml.Return {
//				panic("mock out the SetNvlinkBwMode method")
//			},
//			SetPersistenceModeFunc: func(enableState nvml.EnableState) nvml.Return {
//				panic("mock out the SetPersistenceMode method")
//			},
//			SetPowerManagementLimitFunc: func(v uint32) nvml.Return {
//				panic("mock out the SetPowerManagementLimit method")
//			},
//			SetPowerManagementLimit_v2Func: func(powerValue_v2 *nvml.PowerValue_v2) nvml.Return {
//				panic("mock out the SetPowerManagementLimit_v2 method")
//			},
//			SetTemperatureThresholdFunc: func(temperatureThresholds nvml.TemperatureThresholds, n int) nvml.Return {
//				panic("mock out the SetTemperatureThreshold method")
//			},
//			SetVgpuCapabilitiesFunc: func(deviceVgpuCapability nvml.DeviceVgpuCapability, enableState nvml.EnableState) nvml.Return {
//				panic("mock out the SetVgpuCapabilities method")
//			},
//			SetVgpuHeterogeneousModeFunc: func(vgpuHeterogeneousMode nvml.VgpuHeterogeneousMode) nvml.Return {
//				panic("mock out the SetVgpuHeterogeneousMode method")
//			},
//			SetVgpuSchedulerStateFunc: func(vgpuSchedulerSetState *nvml.VgpuSchedulerSetState) nvml.Return {
//				panic("mock out the SetVgpuSchedulerState method")
//			},
//			SetVirtualizationModeFunc: func(gpuVirtualizationMode nvml.GpuVirtualizationMode) nvml.Return {
//				panic("mock out the SetVirtualizationMode method")
//			},
//			ValidateInforomFunc: func() nvml.Return {
//				panic("mock out the ValidateInforom method")
//			},
//			VgpuTypeGetMaxInstancesFunc: func(vgpuTypeId nvml.VgpuTypeId) (int, nvml.Return) {
//				panic("mock out the VgpuTypeGetMaxInstances method")
//			},
//			WorkloadPowerProfileClearRequestedProfilesFunc: func(workloadPowerProfileRequestedProfiles *nvml.WorkloadPowerProfileRequestedProfiles) nvml.Return {
//				panic("mock out the WorkloadPowerProfileClearRequestedProfiles method")
//			},
//			WorkloadPowerProfileGetCurrentProfilesFunc: func() (nvml.WorkloadPowerProfileCurrentProfiles, nvml.Return) {
//				panic("mock out the WorkloadPowerProfileGetCurrentProfiles method")
//			},
//			WorkloadPowerProfileGetProfilesInfoFunc: func() (nvml.WorkloadPowerProfileProfilesInfo, nvml.Return) {
//				panic("mock out the WorkloadPowerProfileGetProfilesInfo method")
//			},
//			WorkloadPowerProfileSetRequestedProfilesFunc: func(workloadPowerProfileRequestedProfiles *nvml.WorkloadPowerProfileRequestedProfiles) nvml.Return {
//				panic("mock out the WorkloadPowerProfileSetRequestedProfiles method")
//			},
//		}
//
//		// use mockedDevice in code that requires nvml.Device
//		// and then make assertions.
//
//	}
type Device struct {
	// ClearAccountingPidsFunc mocks the ClearAccountingPids method.
	ClearAccountingPidsFunc func() nvml.Return

	// ClearCpuAffinityFunc mocks the ClearCpuAffinity method.
	ClearCpuAffinityFunc func() nvml.Return

	// ClearEccErrorCountsFunc mocks the ClearEccErrorCounts method.
	ClearEccErrorCountsFunc func(eccCounterType nvml.EccCounterType) nvml.Return

	// ClearFieldValuesFunc mocks the ClearFieldValues method.
	ClearFieldValuesFunc func(fieldValues []nvml.FieldValue) nvml.Return

	// CreateGpuInstanceFunc mocks the CreateGpuInstance method.
	CreateGpuInstanceFunc func(gpuInstanceProfileInfo *nvml.GpuInstanceProfileInfo) (nvml.GpuInstance, nvml.Return)

	// CreateGpuInstanceWithPlacementFunc mocks the CreateGpuInstanceWithPlacement method.
	CreateGpuInstanceWithPlacementFunc func(gpuInstanceProfileInfo *nvml.GpuInstanceProfileInfo, gpuInstancePlacement *nvml.GpuInstancePlacement) (nvml.GpuInstance, nvml.Return)

	// FreezeNvLinkUtilizationCounterFunc mocks the FreezeNvLinkUtilizationCounter method.
	FreezeNvLinkUtilizationCounterFunc func(n1 int, n2 int, enableState nvml.EnableState) nvml.Return

	// GetAPIRestrictionFunc mocks the GetAPIRestriction method.
	GetAPIRestrictionFunc func(restrictedAPI nvml.RestrictedAPI) (nvml.EnableState, nvml.Return)

	// GetAccountingBufferSizeFunc mocks the GetAccountingBufferSize method.
	GetAccountingBufferSizeFunc func() (int, nvml.Return)

	// GetAccountingModeFunc mocks the GetAccountingMode method.
	GetAccountingModeFunc func() (nvml.EnableState, nvml.Return)

	// GetAccountingPidsFunc mocks the GetAccountingPids method.
	GetAccountingPidsFunc func() ([]int, nvml.Return)

	// GetAccountingStatsFunc mocks the GetAccountingStats method.
	GetAccountingStatsFunc func(v uint32) (nvml.AccountingStats, nvml.Return)

	// GetActiveVgpusFunc mocks the GetActiveVgpus method.
	GetActiveVgpusFunc func() ([]nvml.VgpuInstance, nvml.Return)

	// GetAdaptiveClockInfoStatusFunc mocks the GetAdaptiveClockInfoStatus method.
	GetAdaptiveClockInfoStatusFunc func() (uint32, nvml.Return)

	// GetAddressingModeFunc mocks the GetAddressingMode method.
	GetAddressingModeFunc func() (nvml.DeviceAddressingMode, nvml.Return)

	// GetApplicationsClockFunc mocks the GetApplicationsClock method.
	GetApplicationsClockFunc func(clockType nvml.ClockType) (uint32, nvml.Return)

	// GetArchitectureFunc mocks the GetArchitecture method.
	GetArchitectureFunc func() (nvml.DeviceArchitecture, nvml.Return)

	// GetAttributesFunc mocks the GetAttributes method.
	GetAttributesFunc func() (nvml.DeviceAttributes, nvml.Return)

	// GetAutoBoostedClocksEnabledFunc mocks the GetAutoBoostedClocksEnabled method.
	GetAutoBoostedClocksEnabledFunc func() (nvml.EnableState, nvml.EnableState, nvml.Return)

	// GetBAR1MemoryInfoFunc mocks the GetBAR1MemoryInfo method.
	GetBAR1MemoryInfoFunc func() (nvml.BAR1Memory, nvml.Return)

	// GetBoardIdFunc mocks the GetBoardId method.
	GetBoardIdFunc func() (uint32, nvml.Return)

	// GetBoardPartNumberFunc mocks the GetBoardPartNumber method.
	GetBoardPartNumberFunc func() (string, nvml.Return)

	// GetBrandFunc mocks the GetBrand method.
	GetBrandFunc func() (nvml.BrandType, nvml.Return)

	// GetBridgeChipInfoFunc mocks the GetBridgeChipInfo method.
	GetBridgeChipInfoFunc func() (nvml.BridgeChipHierarchy, nvml.Return)

	// GetBusTypeFunc mocks the GetBusType method.
	GetBusTypeFunc func() (nvml.BusType, nvml.Return)

	// GetC2cModeInfoVFunc mocks the GetC2cModeInfoV method.
	GetC2cModeInfoVFunc func() nvml.C2cModeInfoHandler

	// GetCapabilitiesFunc mocks the GetCapabilities method.
	GetCapabilitiesFunc func() (nvml.DeviceCapabilities, nvml.Return)

	// GetClkMonStatusFunc mocks the GetClkMonStatus method.
	GetClkMonStatusFunc func() (nvml.ClkMonStatus, nvml.Return)

	// GetClockFunc mocks the GetClock method.
	GetClockFunc func(clockType nvml.ClockType, clockId nvml.ClockId) (uint32, nvml.Return)

	// GetClockInfoFunc mocks the GetClockInfo method.
	GetClockInfoFunc func(clockType nvml.ClockType) (uint32, nvml.Return)

	// GetClockOffsetsFunc mocks the GetClockOffsets method.
	GetClockOffsetsFunc func() (nvml.ClockOffset, nvml.Return)

	// GetComputeInstanceIdFunc mocks the GetComputeInstanceId method.
	GetComputeInstanceIdFunc func() (int, nvml.Return)

	// GetComputeModeFunc mocks the GetComputeMode method.
	GetComputeModeFunc func() (nvml.ComputeMode, nvml.Return)

	// GetComputeRunningProcessesFunc mocks the GetComputeRunningProcesses method.
	GetComputeRunningProcessesFunc func() ([]nvml.ProcessInfo, nvml.Return)

	// GetConfComputeGpuAttestationReportFunc mocks the GetConfComputeGpuAttestationReport method.
	GetConfComputeGpuAttestationReportFunc func(confComputeGpuAttestationReport *nvml.ConfComputeGpuAttestationReport) nvml.Return

	// GetConfComputeGpuCertificateFunc mocks the GetConfComputeGpuCertificate method.
	GetConfComputeGpuCertificateFunc func() (nvml.ConfComputeGpuCertificate, nvml.Return)

	// GetConfComputeMemSizeInfoFunc mocks the GetConfComputeMemSizeInfo method.
	GetConfComputeMemSizeInfoFunc func() (nvml.ConfComputeMemSizeInfo, nvml.Return)

	// GetConfComputeProtectedMemoryUsageFunc mocks the GetConfComputeProtectedMemoryUsage method.
	GetConfComputeProtectedMemoryUsageFunc func() (nvml.Memory, nvml.Return)

	// GetCoolerInfoFunc mocks the GetCoolerInfo method.
	GetCoolerInfoFunc func() (nvml.CoolerInfo, nvml.Return)

	// GetCpuAffinityFunc mocks the GetCpuAffinity method.
	GetCpuAffinityFunc func(n int) ([]uint, nvml.Return)

	// GetCpuAffinityWithinScopeFunc mocks the GetCpuAffinityWithinScope method.
	GetCpuAffinityWithinScopeFunc func(n int, affinityScope nvml.AffinityScope) ([]uint, nvml.Return)

	// GetCreatableVgpusFunc mocks the GetCreatableVgpus method.
	GetCreatableVgpusFunc func() ([]nvml.VgpuTypeId, nvml.Return)

	// GetCudaComputeCapabilityFunc mocks the GetCudaComputeCapability method.
	GetCudaComputeCapabilityFunc func() (int, int, nvml.Return)

	// GetCurrPcieLinkGenerationFunc mocks the GetCurrPcieLinkGeneration method.
	GetCurrPcieLinkGenerationFunc func() (int, nvml.Return)

	// GetCurrPcieLinkWidthFunc mocks the GetCurrPcieLinkWidth method.
	GetCurrPcieLinkWidthFunc func() (int, nvml.Return)

	// GetCurrentClockFreqsFunc mocks the GetCurrentClockFreqs method.
	GetCurrentClockFreqsFunc func() (nvml.DeviceCurrentClockFreqs, nvml.Return)

	// GetCurrentClocksEventReasonsFunc mocks the GetCurrentClocksEventReasons method.
	GetCurrentClocksEventReasonsFunc func() (uint64, nvml.Return)

	// GetCurrentClocksThrottleReasonsFunc mocks the GetCurrentClocksThrottleReasons method.
	GetCurrentClocksThrottleReasonsFunc func() (uint64, nvml.Return)

	// GetDecoderUtilizationFunc mocks the GetDecoderUtilization method.
	GetDecoderUtilizationFunc func() (uint32, uint32, nvml.Return)

	// GetDefaultApplicationsClockFunc mocks the GetDefaultApplicationsClock method.
	GetDefaultApplicationsClockFunc func(clockType nvml.ClockType) (uint32, nvml.Return)

	// GetDefaultEccModeFunc mocks the GetDefaultEccMode method.
	GetDefaultEccModeFunc func() (nvml.EnableState, nvml.Return)

	// GetDetailedEccErrorsFunc mocks the GetDetailedEccErrors method.
	GetDetailedEccErrorsFunc func(memoryErrorType nvml.MemoryErrorType, eccCounterType nvml.EccCounterType) (nvml.EccErrorCounts, nvml.Return)

	// GetDeviceHandleFromMigDeviceHandleFunc mocks the GetDeviceHandleFromMigDeviceHandle method.
	GetDeviceHandleFromMigDeviceHandleFunc func() (nvml.Device, nvml.Return)

	// GetDisplayActiveFunc mocks the GetDisplayActive method.
	GetDisplayActiveFunc func() (nvml.EnableState, nvml.Return)

	// GetDisplayModeFunc mocks the GetDisplayMode method.
	GetDisplayModeFunc func() (nvml.EnableState, nvml.Return)

	// GetDramEncryptionModeFunc mocks the GetDramEncryptionMode method.
	GetDramEncryptionModeFunc func() (nvml.DramEncryptionInfo, nvml.DramEncryptionInfo, nvml.Return)

	// GetDriverModelFunc mocks the GetDriverModel method.
	GetDriverModelFunc func() (nvml.DriverModel, nvml.DriverModel, nvml.Return)

	// GetDriverModel_v2Func mocks the GetDriverModel_v2 method.
	GetDriverModel_v2Func func() (nvml.DriverModel, nvml.DriverModel, nvml.Return)

	// GetDynamicPstatesInfoFunc mocks the GetDynamicPstatesInfo method.
	GetDynamicPstatesInfoFunc func() (nvml.GpuDynamicPstatesInfo, nvml.Return)

	// GetEccModeFunc mocks the GetEccMode method.
	GetEccModeFunc func() (nvml.EnableState, nvml.EnableState, nvml.Return)

	// GetEncoderCapacityFunc mocks the GetEncoderCapacity method.
	GetEncoderCapacityFunc func(encoderType nvml.EncoderType) (int, nvml.Return)

	// GetEncoderSessionsFunc mocks the GetEncoderSessions method.
	GetEncoderSessionsFunc func() ([]nvml.EncoderSessionInfo, nvml.Return)

	// GetEncoderStatsFunc mocks the GetEncoderStats method.
	GetEncoderStatsFunc func() (int, uint32, uint32, nvml.Return)

	// GetEncoderUtilizationFunc mocks the GetEncoderUtilization method.
	GetEncoderUtilizationFunc func() (uint32, uint32, nvml.Return)

	// GetEnforcedPowerLimitFunc mocks the GetEnforcedPowerLimit method.
	GetEnforcedPowerLimitFunc func() (uint32, nvml.Return)

	// GetFBCSessionsFunc mocks the GetFBCSessions method.
	GetFBCSessionsFunc func() ([]nvml.FBCSessionInfo, nvml.Return)

	// GetFBCStatsFunc mocks the GetFBCStats method.
	GetFBCStatsFunc func() (nvml.FBCStats, nvml.Return)

	// GetFanControlPolicy_v2Func mocks the GetFanControlPolicy_v2 method.
	GetFanControlPolicy_v2Func func(n int) (nvml.FanControlPolicy, nvml.Return)

	// GetFanSpeedFunc mocks the GetFanSpeed method.
	GetFanSpeedFunc func() (uint32, nvml.Return)

	// GetFanSpeedRPMFunc mocks the GetFanSpeedRPM method.
	GetFanSpeedRPMFunc func() (nvml.FanSpeedInfo, nvml.Return)

	// GetFanSpeed_v2Func mocks the GetFanSpeed_v2 method.
	GetFanSpeed_v2Func func(n int) (uint32, nvml.Return)

	// GetFieldValuesFunc mocks the GetFieldValues method.
	GetFieldValuesFunc func(fieldValues []nvml.FieldValue) nvml.Return

	// GetGpcClkMinMaxVfOffsetFunc mocks the GetGpcClkMinMaxVfOffset method.
	GetGpcClkMinMaxVfOffsetFunc func() (int, int, nvml.Return)

	// GetGpcClkVfOffsetFunc mocks the GetGpcClkVfOffset method.
	GetGpcClkVfOffsetFunc func() (int, nvml.Return)

	// GetGpuFabricInfoFunc mocks the GetGpuFabricInfo method.
	GetGpuFabricInfoFunc func() (nvml.GpuFabricInfo, nvml.Return)

	// GetGpuFabricInfoVFunc mocks the GetGpuFabricInfoV method.
	GetGpuFabricInfoVFunc func() nvml.GpuFabricInfoHandler

	// GetGpuInstanceByIdFunc mocks the GetGpuInstanceById method.
	GetGpuInstanceByIdFunc func(n int) (nvml.GpuInstance, nvml.Return)

	// GetGpuInstanceIdFunc mocks the GetGpuInstanceId method.
	GetGpuInstanceIdFunc func() (int, nvml.Return)

	// GetGpuInstancePossiblePlacementsFunc mocks the GetGpuInstancePossiblePlacements method.
	GetGpuInstancePossiblePlacementsFunc func(gpuInstanceProfileInfo *nvml.GpuInstanceProfileInfo) ([]nvml.GpuInstancePlacement, nvml.Return)

	// GetGpuInstanceProfileInfoFunc mocks the GetGpuInstanceProfileInfo method.
	GetGpuInstanceProfileInfoFunc func(n int) (nvml.GpuInstanceProfileInfo, nvml.Return)

	// GetGpuInstanceProfileInfoByIdVFunc mocks the GetGpuInstanceProfileInfoByIdV method.
	GetGpuInstanceProfileInfoByIdVFunc func(n int) nvml.GpuInstanceProfileInfoByIdHandler

	// GetGpuInstanceProfileInfoVFunc mocks the GetGpuInstanceProfileInfoV method.
	GetGpuInstanceProfileInfoVFunc func(n int) nvml.GpuInstanceProfileInfoHandler

	// GetGpuInstanceRemainingCapacityFunc mocks the GetGpuInstanceRemainingCapacity method.
	GetGpuInstanceRemainingCapacityFunc func(gpuInstanceProfileInfo *nvml.GpuInstanceProfileInfo) (int, nvml.Return)

	// GetGpuInstancesFunc mocks the GetGpuInstances method.
	GetGpuInstancesFunc func(gpuInstanceProfileInfo *nvml.GpuInstanceProfileInfo) ([]nvml.GpuInstance, nvml.Return)

	// GetGpuMaxPcieLinkGenerationFunc mocks the GetGpuMaxPcieLinkGeneration method.
	GetGpuMaxPcieLinkGenerationFunc func() (int, nvml.Return)

	// GetGpuOperationModeFunc mocks the GetGpuOperationMode method.
	GetGpuOperationModeFunc func() (nvml.GpuOperationMode, nvml.GpuOperationMode, nvml.Return)

	// GetGraphicsRunningProcessesFunc mocks the GetGraphicsRunningProcesses method.
	GetGraphicsRunningProcessesFunc func() ([]nvml.ProcessInfo, nvml.Return)

	// GetGridLicensableFeaturesFunc mocks the GetGridLicensableFeatures method.
	GetGridLicensableFeaturesFunc func() (nvml.GridLicensableFeatures, nvml.Return)

	// GetGspFirmwareModeFunc mocks the GetGspFirmwareMode method.
	GetGspFirmwareModeFunc func() (bool, bool, nvml.Return)

	// GetGspFirmwareVersionFunc mocks the GetGspFirmwareVersion method.
	GetGspFirmwareVersionFunc func() (string, nvml.Return)

	// GetHostVgpuModeFunc mocks the GetHostVgpuMode method.
	GetHostVgpuModeFunc func() (nvml.HostVgpuMode, nvml.Return)

	// GetIndexFunc mocks the GetIndex method.
	GetIndexFunc func() (int, nvml.Return)

	// GetInforomConfigurationChecksumFunc mocks the GetInforomConfigurationChecksum method.
	GetInforomConfigurationChecksumFunc func() (uint32, nvml.Return)

	// GetInforomImageVersionFunc mocks the GetInforomImageVersion method.
	GetInforomImageVersionFunc func() (string, nvml.Return)

	// GetInforomVersionFunc mocks the GetInforomVersion method.
	GetInforomVersionFunc func(inforomObject nvml.InforomObject) (string, nvml.Return)

	// GetIrqNumFunc mocks the GetIrqNum method.
	GetIrqNumFunc func() (int, nvml.Return)

	// GetJpgUtilizationFunc mocks the GetJpgUtilization method.
	GetJpgUtilizationFunc func() (uint32, uint32, nvml.Return)

	// GetLastBBXFlushTimeFunc mocks the GetLastBBXFlushTime method.
	GetLastBBXFlushTimeFunc func() (uint64, uint, nvml.Return)

	// GetMPSComputeRunningProcessesFunc mocks the GetMPSComputeRunningProcesses method.
	GetMPSComputeRunningProcessesFunc func() ([]nvml.ProcessInfo, nvml.Return)

	// GetMarginTemperatureFunc mocks the GetMarginTemperature method.
	GetMarginTemperatureFunc func() (nvml.MarginTemperature, nvml.Return)

	// GetMaxClockInfoFunc mocks the GetMaxClockInfo method.
	GetMaxClockInfoFunc func(clockType nvml.ClockType) (uint32, nvml.Return)

	// GetMaxCustomerBoostClockFunc mocks the GetMaxCustomerBoostClock method.
	GetMaxCustomerBoostClockFunc func(clockType nvml.ClockType) (uint32, nvml.Return)

	// GetMaxMigDeviceCountFunc mocks the GetMaxMigDeviceCount method.
	GetMaxMigDeviceCountFunc func() (int, nvml.Return)

	// GetMaxPcieLinkGenerationFunc mocks the GetMaxPcieLinkGeneration method.
	GetMaxPcieLinkGenerationFunc func() (int, nvml.Return)

	// GetMaxPcieLinkWidthFunc mocks the GetMaxPcieLinkWidth method.
	GetMaxPcieLinkWidthFunc func() (int, nvml.Return)

	// GetMemClkMinMaxVfOffsetFunc mocks the GetMemClkMinMaxVfOffset method.
	GetMemClkMinMaxVfOffsetFunc func() (int, int, nvml.Return)

	// GetMemClkVfOffsetFunc mocks the GetMemClkVfOffset method.
	GetMemClkVfOffsetFunc func() (int, nvml.Return)

	// GetMemoryAffinityFunc mocks the GetMemoryAffinity method.
	GetMemoryAffinityFunc func(n int, affinityScope nvml.AffinityScope) ([]uint, nvml.Return)

	// GetMemoryBusWidthFunc mocks the GetMemoryBusWidth method.
	GetMemoryBusWidthFunc func() (uint32, nvml.Return)

	// GetMemoryErrorCounterFunc mocks the GetMemoryErrorCounter method.
	GetMemoryErrorCounterFunc func(memoryErrorType nvml.MemoryErrorType, eccCounterType nvml.EccCounterType, memoryLocation nvml.MemoryLocation) (uint64, nvml.Return)

	// GetMemoryInfoFunc mocks the GetMemoryInfo method.
	GetMemoryInfoFunc func() (nvml.Memory, nvml.Return)

	// GetMemoryInfo_v2Func mocks the GetMemoryInfo_v2 method.
	GetMemoryInfo_v2Func func() (nvml.Memory_v2, nvml.Return)

	// GetMigDeviceHandleByIndexFunc mocks the GetMigDeviceHandleByIndex method.
	GetMigDeviceHandleByIndexFunc func(n int) (nvml.Device, nvml.Return)

	// GetMigModeFunc mocks the GetMigMode method.
	GetMigModeFunc func() (int, int, nvml.Return)

	// GetMinMaxClockOfPStateFunc mocks the GetMinMaxClockOfPState method.
	GetMinMaxClockOfPStateFunc func(clockType nvml.ClockType, pstates nvml.Pstates) (uint32, uint32, nvml.Return)

	// GetMinMaxFanSpeedFunc mocks the GetMinMaxFanSpeed method.
	GetMinMaxFanSpeedFunc func() (int, int, nvml.Return)

	// GetMinorNumberFunc mocks the GetMinorNumber method.
	GetMinorNumberFunc func() (int, nvml.Return)

	// GetModuleIdFunc mocks the GetModuleId method.
	GetModuleIdFunc func() (int, nvml.Return)

	// GetMultiGpuBoardFunc mocks the GetMultiGpuBoard method.
	GetMultiGpuBoardFunc func() (int, nvml.Return)

	// GetNameFunc mocks the GetName method.
	GetNameFunc func() (string, nvml.Return)

	// GetNumFansFunc mocks the GetNumFans method.
	GetNumFansFunc func() (int, nvml.Return)

	// GetNumGpuCoresFunc mocks the GetNumGpuCores method.
	GetNumGpuCoresFunc func() (int, nvml.Return)

	// GetNumaNodeIdFunc mocks the GetNumaNodeId method.
	GetNumaNodeIdFunc func() (int, nvml.Return)

	// GetNvLinkCapabilityFunc mocks the GetNvLinkCapability method.
	GetNvLinkCapabilityFunc func(n int, nvLinkCapability nvml.NvLinkCapability) (uint32, nvml.Return)

	// GetNvLinkErrorCounterFunc mocks the GetNvLinkErrorCounter method.
	GetNvLinkErrorCounterFunc func(n int, nvLinkErrorCounter nvml.NvLinkErrorCounter) (uint64, nvml.Return)

	// GetNvLinkInfoFunc mocks the GetNvLinkInfo method.
	GetNvLinkInfoFunc func() nvml.NvLinkInfoHandler

	// GetNvLinkRemoteDeviceTypeFunc mocks the GetNvLinkRemoteDeviceType method.
	GetNvLinkRemoteDeviceTypeFunc func(n int) (nvml.IntNvLinkDeviceType, nvml.Return)

	// GetNvLinkRemotePciInfoFunc mocks the GetNvLinkRemotePciInfo method.
	GetNvLinkRemotePciInfoFunc func(n int) (nvml.PciInfo, nvml.Return)

	// GetNvLinkStateFunc mocks the GetNvLinkState method.
	GetNvLinkStateFunc func(n int) (nvml.EnableState, nvml.Return)

	// GetNvLinkUtilizationControlFunc mocks the GetNvLinkUtilizationControl method.
	GetNvLinkUtilizationControlFunc func(n1 int, n2 int) (nvml.NvLinkUtilizationControl, nvml.Return)

	// GetNvLinkUtilizationCounterFunc mocks the GetNvLinkUtilizationCounter method.
	GetNvLinkUtilizationCounterFunc func(n1 int, n2 int) (uint64, uint64, nvml.Return)

	// GetNvLinkVersionFunc mocks the GetNvLinkVersion method.
	GetNvLinkVersionFunc func(n int) (uint32, nvml.Return)

	// GetNvlinkBwModeFunc mocks the GetNvlinkBwMode method.
	GetNvlinkBwModeFunc func() (nvml.NvlinkGetBwMode, nvml.Return)

	// GetNvlinkSupportedBwModesFunc mocks the GetNvlinkSupportedBwModes method.
	GetNvlinkSupportedBwModesFunc func() (nvml.NvlinkSupportedBwModes, nvml.Return)

	// GetOfaUtilizationFunc mocks the GetOfaUtilization method.
	GetOfaUtilizationFunc func() (uint32, uint32, nvml.Return)

	// GetP2PStatusFunc mocks the GetP2PStatus method.
	GetP2PStatusFunc func(device nvml.Device, gpuP2PCapsIndex nvml.GpuP2PCapsIndex) (nvml.GpuP2PStatus, nvml.Return)

	// GetPciInfoFunc mocks the GetPciInfo method.
	GetPciInfoFunc func() (nvml.PciInfo, nvml.Return)

	// GetPciInfoExtFunc mocks the GetPciInfoExt method.
	GetPciInfoExtFunc func() (nvml.PciInfoExt, nvml.Return)

	// GetPcieLinkMaxSpeedFunc mocks the GetPcieLinkMaxSpeed method.
	GetPcieLinkMaxSpeedFunc func() (uint32, nvml.Return)

	// GetPcieReplayCounterFunc mocks the GetPcieReplayCounter method.
	GetPcieReplayCounterFunc func() (int, nvml.Return)

	// GetPcieSpeedFunc mocks the GetPcieSpeed method.
	GetPcieSpeedFunc func() (int, nvml.Return)

	// GetPcieThroughputFunc mocks the GetPcieThroughput method.
	GetPcieThroughputFunc func(pcieUtilCounter nvml.PcieUtilCounter) (uint32, nvml.Return)

	// GetPdiFunc mocks the GetPdi method.
	GetPdiFunc func() (nvml.Pdi, nvml.Return)

	// GetPerformanceModesFunc mocks the GetPerformanceModes method.
	GetPerformanceModesFunc func() (nvml.DevicePerfModes, nvml.Return)

	// GetPerformanceStateFunc mocks the GetPerformanceState method.
	GetPerformanceStateFunc func() (nvml.Pstates, nvml.Return)

	// GetPersistenceModeFunc mocks the GetPersistenceMode method.
	GetPersistenceModeFunc func() (nvml.EnableState, nvml.Return)

	// GetPgpuMetadataStringFunc mocks the GetPgpuMetadataString method.
	GetPgpuMetadataStringFunc func() (string, nvml.Return)

	// GetPlatformInfoFunc mocks the GetPlatformInfo method.
	GetPlatformInfoFunc func() (nvml.PlatformInfo, nvml.Return)

	// GetPowerManagementDefaultLimitFunc mocks the GetPowerManagementDefaultLimit method.
	GetPowerManagementDefaultLimitFunc func() (uint32, nvml.Return)

	// GetPowerManagementLimitFunc mocks the GetPowerManagementLimit method.
	GetPowerManagementLimitFunc func() (uint32, nvml.Return)

	// GetPowerManagementLimitConstraintsFunc mocks the GetPowerManagementLimitConstraints method.
	GetPowerManagementLimitConstraintsFunc func() (uint32, uint32, nvml.Return)

	// GetPowerManagementModeFunc mocks the GetPowerManagementMode method.
	GetPowerManagementModeFunc func() (nvml.EnableState, nvml.Return)

	// GetPowerMizerMode_v1Func mocks the GetPowerMizerMode_v1 method.
	GetPowerMizerMode_v1Func func() (nvml.DevicePowerMizerModes_v1, nvml.Return)

	// GetPowerSourceFunc mocks the GetPowerSource method.
	GetPowerSourceFunc func() (nvml.PowerSource, nvml.Return)

	// GetPowerStateFunc mocks the GetPowerState method.
	GetPowerStateFunc func() (nvml.Pstates, nvml.Return)

	// GetPowerUsageFunc mocks the GetPowerUsage method.
	GetPowerUsageFunc func() (uint32, nvml.Return)

	// GetProcessUtilizationFunc mocks the GetProcessUtilization method.
	GetProcessUtilizationFunc func(v uint64) ([]nvml.ProcessUtilizationSample, nvml.Return)

	// GetProcessesUtilizationInfoFunc mocks the GetProcessesUtilizationInfo method.
	GetProcessesUtilizationInfoFunc func() (nvml.ProcessesUtilizationInfo, nvml.Return)

	// GetRemappedRowsFunc mocks the GetRemappedRows method.
	GetRemappedRowsFunc func() (int, int, bool, bool, nvml.Return)

	// GetRepairStatusFunc mocks the GetRepairStatus method.
	GetRepairStatusFunc func() (nvml.RepairStatus, nvml.Return)

	// GetRetiredPagesFunc mocks the GetRetiredPages method.
	GetRetiredPagesFunc func(pageRetirementCause nvml.PageRetirementCause) ([]uint64, nvml.Return)

	// GetRetiredPagesPendingStatusFunc mocks the GetRetiredPagesPendingStatus method.
	GetRetiredPagesPendingStatusFunc func() (nvml.EnableState, nvml.Return)

	// GetRetiredPages_v2Func mocks the GetRetiredPages_v2 method.
	GetRetiredPages_v2Func func(pageRetirementCause nvml.PageRetirementCause) ([]uint64, []uint64, nvml.Return)

	// GetRowRemapperHistogramFunc mocks the GetRowRemapperHistogram method.
	GetRowRemapperHistogramFunc func() (nvml.RowRemapperHistogramValues, nvml.Return)

	// GetRunningProcessDetailListFunc mocks the GetRunningProcessDetailList method.
	GetRunningProcessDetailListFunc func() (nvml.ProcessDetailList, nvml.Return)

	// GetSamplesFunc mocks the GetSamples method.
	GetSamplesFunc func(samplingType nvml.SamplingType, v uint64) (nvml.ValueType, []nvml.Sample, nvml.Return)

	// GetSerialFunc mocks the GetSerial method.
	GetSerialFunc func() (string, nvml.Return)

	// GetSramEccErrorStatusFunc mocks the GetSramEccErrorStatus method.
	GetSramEccErrorStatusFunc func() (nvml.EccSramErrorStatus, nvml.Return)

	// GetSramUniqueUncorrectedEccErrorCountsFunc mocks the GetSramUniqueUncorrectedEccErrorCounts method.
	GetSramUniqueUncorrectedEccErrorCountsFunc func(eccSramUniqueUncorrectedErrorCounts *nvml.EccSramUniqueUncorrectedErrorCounts) nvml.Return

	// GetSupportedClocksEventReasonsFunc mocks the GetSupportedClocksEventReasons method.
	GetSupportedClocksEventReasonsFunc func() (uint64, nvml.Return)

	// GetSupportedClocksThrottleReasonsFunc mocks the GetSupportedClocksThrottleReasons method.
	GetSupportedClocksThrottleReasonsFunc func() (uint64, nvml.Return)

	// GetSupportedEventTypesFunc mocks the GetSupportedEventTypes method.
	GetSupportedEventTypesFunc func() (uint64, nvml.Return)

	// GetSupportedGraphicsClocksFunc mocks the GetSupportedGraphicsClocks method.
	GetSupportedGraphicsClocksFunc func(n int) (int, uint32, nvml.Return)

	// GetSupportedMemoryClocksFunc mocks the GetSupportedMemoryClocks method.
	GetSupportedMemoryClocksFunc func() (int, uint32, nvml.Return)

	// GetSupportedPerformanceStatesFunc mocks the GetSupportedPerformanceStates method.
	GetSupportedPerformanceStatesFunc func() ([]nvml.Pstates, nvml.Return)

	// GetSupportedVgpusFunc mocks the GetSupportedVgpus method.
	GetSupportedVgpusFunc func() ([]nvml.VgpuTypeId, nvml.Return)

	// GetTargetFanSpeedFunc mocks the GetTargetFanSpeed method.
	GetTargetFanSpeedFunc func(n int) (int, nvml.Return)

	// GetTemperatureFunc mocks the GetTemperature method.
	GetTemperatureFunc func(temperatureSensors nvml.TemperatureSensors) (uint32, nvml.Return)

	// GetTemperatureThresholdFunc mocks the GetTemperatureThreshold method.
	GetTemperatureThresholdFunc func(temperatureThresholds nvml.TemperatureThresholds) (uint32, nvml.Return)

	// GetTemperatureVFunc mocks the GetTemperatureV method.
	GetTemperatureVFunc func() nvml.TemperatureHandler

	// GetThermalSettingsFunc mocks the GetThermalSettings method.
	GetThermalSettingsFunc func(v uint32) (nvml.GpuThermalSettings, nvml.Return)

	// GetTopologyCommonAncestorFunc mocks the GetTopologyCommonAncestor method.
	GetTopologyCommonAncestorFunc func(device nvml.Device) (nvml.GpuTopologyLevel, nvml.Return)

	// GetTopologyNearestGpusFunc mocks the GetTopologyNearestGpus method.
	GetTopologyNearestGpusFunc func(gpuTopologyLevel nvml.GpuTopologyLevel) ([]nvml.Device, nvml.Return)

	// GetTotalEccErrorsFunc mocks the GetTotalEccErrors method.
	GetTotalEccErrorsFunc func(memoryErrorType nvml.MemoryErrorType, eccCounterType nvml.EccCounterType) (uint64, nvml.Return)

	// GetTotalEnergyConsumptionFunc mocks the GetTotalEnergyConsumption method.
	GetTotalEnergyConsumptionFunc func() (uint64, nvml.Return)

	// GetUUIDFunc mocks the GetUUID method.
	GetUUIDFunc func() (string, nvml.Return)

	// GetUtilizationRatesFunc mocks the GetUtilizationRates method.
	GetUtilizationRatesFunc func() (nvml.Utilization, nvml.Return)

	// GetVbiosVersionFunc mocks the GetVbiosVersion method.
	GetVbiosVersionFunc func() (string, nvml.Return)

	// GetVgpuCapabilitiesFunc mocks the GetVgpuCapabilities method.
	GetVgpuCapabilitiesFunc func(deviceVgpuCapability nvml.DeviceVgpuCapability) (bool, nvml.Return)

	// GetVgpuHeterogeneousModeFunc mocks the GetVgpuHeterogeneousMode method.
	GetVgpuHeterogeneousModeFunc func() (nvml.VgpuHeterogeneousMode, nvml.Return)

	// GetVgpuInstancesUtilizationInfoFunc mocks the GetVgpuInstancesUtilizationInfo method.
	GetVgpuInstancesUtilizationInfoFunc func() (nvml.VgpuInstancesUtilizationInfo, nvml.Return)

	// GetVgpuMetadataFunc mocks the GetVgpuMetadata method.
	GetVgpuMetadataFunc func() (nvml.VgpuPgpuMetadata, nvml.Return)

	// GetVgpuProcessUtilizationFunc mocks the GetVgpuProcessUtilization method.
	GetVgpuProcessUtilizationFunc func(v uint64) ([]nvml.VgpuProcessUtilizationSample, nvml.Return)

	// GetVgpuProcessesUtilizationInfoFunc mocks the GetVgpuProcessesUtilizationInfo method.
	GetVgpuProcessesUtilizationInfoFunc func() (nvml.VgpuProcessesUtilizationInfo, nvml.Return)

	// GetVgpuSchedulerCapabilitiesFunc mocks the GetVgpuSchedulerCapabilities method.
	GetVgpuSchedulerCapabilitiesFunc func() (nvml.VgpuSchedulerCapabilities, nvml.Return)

	// GetVgpuSchedulerLogFunc mocks the GetVgpuSchedulerLog method.
	GetVgpuSchedulerLogFunc func() (nvml.VgpuSchedulerLog, nvml.Return)

	// GetVgpuSchedulerStateFunc mocks the GetVgpuSchedulerState method.
	GetVgpuSchedulerStateFunc func() (nvml.VgpuSchedulerGetState, nvml.Return)

	// GetVgpuTypeCreatablePlacementsFunc mocks the GetVgpuTypeCreatablePlacements method.
	GetVgpuTypeCreatablePlacementsFunc func(vgpuTypeId nvml.VgpuTypeId) (nvml.VgpuPlacementList, nvml.Return)

	// GetVgpuTypeSupportedPlacementsFunc mocks the GetVgpuTypeSupportedPlacements method.
	GetVgpuTypeSupportedPlacementsFunc func(vgpuTypeId nvml.VgpuTypeId) (nvml.VgpuPlacementList, nvml.Return)

	// GetVgpuUtilizationFunc mocks the GetVgpuUtilization method.
	GetVgpuUtilizationFunc func(v uint64) (nvml.ValueType, []nvml.VgpuInstanceUtilizationSample, nvml.Return)

	// GetViolationStatusFunc mocks the GetViolationStatus method.
	GetViolationStatusFunc func(perfPolicyType nvml.PerfPolicyType) (nvml.ViolationTime, nvml.Return)

	// GetVirtualizationModeFunc mocks the GetVirtualizationMode method.
	GetVirtualizationModeFunc func() (nvml.GpuVirtualizationMode, nvml.Return)

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

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

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

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

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

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

	// IsMigDeviceHandleFunc mocks the IsMigDeviceHandle method.
	IsMigDeviceHandleFunc func() (bool, nvml.Return)

	// OnSameBoardFunc mocks the OnSameBoard method.
	OnSameBoardFunc func(device nvml.Device) (int, nvml.Return)

	// PowerSmoothingActivatePresetProfileFunc mocks the PowerSmoothingActivatePresetProfile method.
	PowerSmoothingActivatePresetProfileFunc func(powerSmoothingProfile *nvml.PowerSmoothingProfile) nvml.Return

	// PowerSmoothingSetStateFunc mocks the PowerSmoothingSetState method.
	PowerSmoothingSetStateFunc func(powerSmoothingState *nvml.PowerSmoothingState) nvml.Return

	// PowerSmoothingUpdatePresetProfileParamFunc mocks the PowerSmoothingUpdatePresetProfileParam method.
	PowerSmoothingUpdatePresetProfileParamFunc func(powerSmoothingProfile *nvml.PowerSmoothingProfile) nvml.Return

	// ReadWritePRM_v1Func mocks the ReadWritePRM_v1 method.
	ReadWritePRM_v1Func func(pRMTLV_v1 *nvml.PRMTLV_v1) nvml.Return

	// RegisterEventsFunc mocks the RegisterEvents method.
	RegisterEventsFunc func(v uint64, eventSet nvml.EventSet) nvml.Return

	// ResetApplicationsClocksFunc mocks the ResetApplicationsClocks method.
	ResetApplicationsClocksFunc func() nvml.Return

	// ResetGpuLockedClocksFunc mocks the ResetGpuLockedClocks method.
	ResetGpuLockedClocksFunc func() nvml.Return

	// ResetMemoryLockedClocksFunc mocks the ResetMemoryLockedClocks method.
	ResetMemoryLockedClocksFunc func() nvml.Return

	// ResetNvLinkErrorCountersFunc mocks the ResetNvLinkErrorCounters method.
	ResetNvLinkErrorCountersFunc func(n int) nvml.Return

	// ResetNvLinkUtilizationCounterFunc mocks the ResetNvLinkUtilizationCounter method.
	ResetNvLinkUtilizationCounterFunc func(n1 int, n2 int) nvml.Return

	// SetAPIRestrictionFunc mocks the SetAPIRestriction method.
	SetAPIRestrictionFunc func(restrictedAPI nvml.RestrictedAPI, enableState nvml.EnableState) nvml.Return

	// SetAccountingModeFunc mocks the SetAccountingMode method.
	SetAccountingModeFunc func(enableState nvml.EnableState) nvml.Return

	// SetApplicationsClocksFunc mocks the SetApplicationsClocks method.
	SetApplicationsClocksFunc func(v1 uint32, v2 uint32) nvml.Return

	// SetAutoBoostedClocksEnabledFunc mocks the SetAutoBoostedClocksEnabled method.
	SetAutoBoostedClocksEnabledFunc func(enableState nvml.EnableState) nvml.Return

	// SetClockOffsetsFunc mocks the SetClockOffsets method.
	SetClockOffsetsFunc func(clockOffset nvml.ClockOffset) nvml.Return

	// SetComputeModeFunc mocks the SetComputeMode method.
	SetComputeModeFunc func(computeMode nvml.ComputeMode) nvml.Return

	// SetConfComputeUnprotectedMemSizeFunc mocks the SetConfComputeUnprotectedMemSize method.
	SetConfComputeUnprotectedMemSizeFunc func(v uint64) nvml.Return

	// SetCpuAffinityFunc mocks the SetCpuAffinity method.
	SetCpuAffinityFunc func() nvml.Return

	// SetDefaultAutoBoostedClocksEnabledFunc mocks the SetDefaultAutoBoostedClocksEnabled method.
	SetDefaultAutoBoostedClocksEnabledFunc func(enableState nvml.EnableState, v uint32) nvml.Return

	// SetDefaultFanSpeed_v2Func mocks the SetDefaultFanSpeed_v2 method.
	SetDefaultFanSpeed_v2Func func(n int) nvml.Return

	// SetDramEncryptionModeFunc mocks the SetDramEncryptionMode method.
	SetDramEncryptionModeFunc func(dramEncryptionInfo *nvml.DramEncryptionInfo) nvml.Return

	// SetDriverModelFunc mocks the SetDriverModel method.
	SetDriverModelFunc func(driverModel nvml.DriverModel, v uint32) nvml.Return

	// SetEccModeFunc mocks the SetEccMode method.
	SetEccModeFunc func(enableState nvml.EnableState) nvml.Return

	// SetFanControlPolicyFunc mocks the SetFanControlPolicy method.
	SetFanControlPolicyFunc func(n int, fanControlPolicy nvml.FanControlPolicy) nvml.Return

	// SetFanSpeed_v2Func mocks the SetFanSpeed_v2 method.
	SetFanSpeed_v2Func func(n1 int, n2 int) nvml.Return

	// SetGpcClkVfOffsetFunc mocks the SetGpcClkVfOffset method.
	SetGpcClkVfOffsetFunc func(n int) nvml.Return

	// SetGpuLockedClocksFunc mocks the SetGpuLockedClocks method.
	SetGpuLockedClocksFunc func(v1 uint32, v2 uint32) nvml.Return

	// SetGpuOperationModeFunc mocks the SetGpuOperationMode method.
	SetGpuOperationModeFunc func(gpuOperationMode nvml.GpuOperationMode) nvml.Return

	// SetMemClkVfOffsetFunc mocks the SetMemClkVfOffset method.
	SetMemClkVfOffsetFunc func(n int) nvml.Return

	// SetMemoryLockedClocksFunc mocks the SetMemoryLockedClocks method.
	SetMemoryLockedClocksFunc func(v1 uint32, v2 uint32) nvml.Return

	// SetMigModeFunc mocks the SetMigMode method.
	SetMigModeFunc func(n int) (nvml.Return, nvml.Return)

	// SetNvLinkDeviceLowPowerThresholdFunc mocks the SetNvLinkDeviceLowPowerThreshold method.
	SetNvLinkDeviceLowPowerThresholdFunc func(nvLinkPowerThres *nvml.NvLinkPowerThres) nvml.Return

	// SetNvLinkUtilizationControlFunc mocks the SetNvLinkUtilizationControl method.
	SetNvLinkUtilizationControlFunc func(n1 int, n2 int, nvLinkUtilizationControl *nvml.NvLinkUtilizationControl, b bool) nvml.Return

	// SetNvlinkBwModeFunc mocks the SetNvlinkBwMode method.
	SetNvlinkBwModeFunc func(nvlinkSetBwMode *nvml.NvlinkSetBwMode) nvml.Return

	// SetPersistenceModeFunc mocks the SetPersistenceMode method.
	SetPersistenceModeFunc func(enableState nvml.EnableState) nvml.Return

	// SetPowerManagementLimitFunc mocks the SetPowerManagementLimit method.
	SetPowerManagementLimitFunc func(v uint32) nvml.Return

	// SetPowerManagementLimit_v2Func mocks the SetPowerManagementLimit_v2 method.
	SetPowerManagementLimit_v2Func func(powerValue_v2 *nvml.PowerValue_v2) nvml.Return

	// SetTemperatureThresholdFunc mocks the SetTemperatureThreshold method.
	SetTemperatureThresholdFunc func(temperatureThresholds nvml.TemperatureThresholds, n int) nvml.Return

	// SetVgpuCapabilitiesFunc mocks the SetVgpuCapabilities method.
	SetVgpuCapabilitiesFunc func(deviceVgpuCapability nvml.DeviceVgpuCapability, enableState nvml.EnableState) nvml.Return

	// SetVgpuHeterogeneousModeFunc mocks the SetVgpuHeterogeneousMode method.
	SetVgpuHeterogeneousModeFunc func(vgpuHeterogeneousMode nvml.VgpuHeterogeneousMode) nvml.Return

	// SetVgpuSchedulerStateFunc mocks the SetVgpuSchedulerState method.
	SetVgpuSchedulerStateFunc func(vgpuSchedulerSetState *nvml.VgpuSchedulerSetState) nvml.Return

	// SetVirtualizationModeFunc mocks the SetVirtualizationMode method.
	SetVirtualizationModeFunc func(gpuVirtualizationMode nvml.GpuVirtualizationMode) nvml.Return

	// ValidateInforomFunc mocks the ValidateInforom method.
	ValidateInforomFunc func() nvml.Return

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

	// WorkloadPowerProfileClearRequestedProfilesFunc mocks the WorkloadPowerProfileClearRequestedProfiles method.
	WorkloadPowerProfileClearRequestedProfilesFunc func(workloadPowerProfileRequestedProfiles *nvml.WorkloadPowerProfileRequestedProfiles) nvml.Return

	// WorkloadPowerProfileGetCurrentProfilesFunc mocks the WorkloadPowerProfileGetCurrentProfiles method.
	WorkloadPowerProfileGetCurrentProfilesFunc func() (nvml.WorkloadPowerProfileCurrentProfiles, nvml.Return)

	// WorkloadPowerProfileGetProfilesInfoFunc mocks the WorkloadPowerProfileGetProfilesInfo method.
	WorkloadPowerProfileGetProfilesInfoFunc func() (nvml.WorkloadPowerProfileProfilesInfo, nvml.Return)

	// WorkloadPowerProfileSetRequestedProfilesFunc mocks the WorkloadPowerProfileSetRequestedProfiles method.
	WorkloadPowerProfileSetRequestedProfilesFunc func(workloadPowerProfileRequestedProfiles *nvml.WorkloadPowerProfileRequestedProfiles) nvml.Return

	// calls tracks calls to the methods.
	calls struct {
		// ClearAccountingPids holds details about calls to the ClearAccountingPids method.
		ClearAccountingPids []struct {
		}
		// ClearCpuAffinity holds details about calls to the ClearCpuAffinity method.
		ClearCpuAffinity []struct {
		}
		// ClearEccErrorCounts holds details about calls to the ClearEccErrorCounts method.
		ClearEccErrorCounts []struct {
			// EccCounterType is the eccCounterType argument value.
			EccCounterType nvml.EccCounterType
		}
		// ClearFieldValues holds details about calls to the ClearFieldValues method.
		ClearFieldValues []struct {
			// FieldValues is the fieldValues argument value.
			FieldValues []nvml.FieldValue
		}
		// CreateGpuInstance holds details about calls to the CreateGpuInstance method.
		CreateGpuInstance []struct {
			// GpuInstanceProfileInfo is the gpuInstanceProfileInfo argument value.
			GpuInstanceProfileInfo *nvml.GpuInstanceProfileInfo
		}
		// CreateGpuInstanceWithPlacement holds details about calls to the CreateGpuInstanceWithPlacement method.
		CreateGpuInstanceWithPlacement []struct {
			// GpuInstanceProfileInfo is the gpuInstanceProfileInfo argument value.
			GpuInstanceProfileInfo *nvml.GpuInstanceProfileInfo
			// GpuInstancePlacement is the gpuInstancePlacement argument value.
			GpuInstancePlacement *nvml.GpuInstancePlacement
		}
		// FreezeNvLinkUtilizationCounter holds details about calls to the FreezeNvLinkUtilizationCounter method.
		FreezeNvLinkUtilizationCounter []struct {
			// 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
		}
		// GetAPIRestriction holds details about calls to the GetAPIRestriction method.
		GetAPIRestriction []struct {
			// RestrictedAPI is the restrictedAPI argument value.
			RestrictedAPI nvml.RestrictedAPI
		}
		// GetAccountingBufferSize holds details about calls to the GetAccountingBufferSize method.
		GetAccountingBufferSize []struct {
		}
		// GetAccountingMode holds details about calls to the GetAccountingMode method.
		GetAccountingMode []struct {
		}
		// GetAccountingPids holds details about calls to the GetAccountingPids method.
		GetAccountingPids []struct {
		}
		// GetAccountingStats holds details about calls to the GetAccountingStats method.
		GetAccountingStats []struct {
			// V is the v argument value.
			V uint32
		}
		// GetActiveVgpus holds details about calls to the GetActiveVgpus method.
		GetActiveVgpus []struct {
		}
		// GetAdaptiveClockInfoStatus holds details about calls to the GetAdaptiveClockInfoStatus method.
		GetAdaptiveClockInfoStatus []struct {
		}
		// GetAddressingMode holds details about calls to the GetAddressingMode method.
		GetAddressingMode []struct {
		}
		// GetApplicationsClock holds details about calls to the GetApplicationsClock method.
		GetApplicationsClock []struct {
			// ClockType is the clockType argument value.
			ClockType nvml.ClockType
		}
		// GetArchitecture holds details about calls to the GetArchitecture method.
		GetArchitecture []struct {
		}
		// GetAttributes holds details about calls to the GetAttributes method.
		GetAttributes []struct {
		}
		// GetAutoBoostedClocksEnabled holds details about calls to the GetAutoBoostedClocksEnabled method.
		GetAutoBoostedClocksEnabled []struct {
		}
		// GetBAR1MemoryInfo holds details about calls to the GetBAR1MemoryInfo method.
		GetBAR1MemoryInfo []struct {
		}
		// GetBoardId holds details about calls to the GetBoardId method.
		GetBoardId []struct {
		}
		// GetBoardPartNumber holds details about calls to the GetBoardPartNumber method.
		GetBoardPartNumber []struct {
		}
		// GetBrand holds details about calls to the GetBrand method.
		GetBrand []struct {
		}
		// GetBridgeChipInfo holds details about calls to the GetBridgeChipInfo method.
		GetBridgeChipInfo []struct {
		}
		// GetBusType holds details about calls to the GetBusType method.
		GetBusType []struct {
		}
		// GetC2cModeInfoV holds details about calls to the GetC2cModeInfoV method.
		GetC2cModeInfoV []struct {
		}
		// GetCapabilities holds details about calls to the GetCapabilities method.
		GetCapabilities []struct {
		}
		// GetClkMonStatus holds details about calls to the GetClkMonStatus method.
		GetClkMonStatus []struct {
		}
		// GetClock holds details about calls to the GetClock method.
		GetClock []struct {
			// ClockType is the clockType argument value.
			ClockType nvml.ClockType
			// ClockId is the clockId argument value.
			ClockId nvml.ClockId
		}
		// GetClockInfo holds details about calls to the GetClockInfo method.
		GetClockInfo []struct {
			// ClockType is the clockType argument value.
			ClockType nvml.ClockType
		}
		// GetClockOffsets holds details about calls to the GetClockOffsets method.
		GetClockOffsets []struct {
		}
		// GetComputeInstanceId holds details about calls to the GetComputeInstanceId method.
		GetComputeInstanceId []struct {
		}
		// GetComputeMode holds details about calls to the GetComputeMode method.
		GetComputeMode []struct {
		}
		// GetComputeRunningProcesses holds details about calls to the GetComputeRunningProcesses method.
		GetComputeRunningProcesses []struct {
		}
		// GetConfComputeGpuAttestationReport holds details about calls to the GetConfComputeGpuAttestationReport method.
		GetConfComputeGpuAttestationReport []struct {
			// ConfComputeGpuAttestationReport is the confComputeGpuAttestationReport argument value.
			ConfComputeGpuAttestationReport *nvml.ConfComputeGpuAttestationReport
		}
		// GetConfComputeGpuCertificate holds details about calls to the GetConfComputeGpuCertificate method.
		GetConfComputeGpuCertificate []struct {
		}
		// GetConfComputeMemSizeInfo holds details about calls to the GetConfComputeMemSizeInfo method.
		GetConfComputeMemSizeInfo []struct {
		}
		// GetConfComputeProtectedMemoryUsage holds details about calls to the GetConfComputeProtectedMemoryUsage method.
		GetConfComputeProtectedMemoryUsage []struct {
		}
		// GetCoolerInfo holds details about calls to the GetCoolerInfo method.
		GetCoolerInfo []struct {
		}
		// GetCpuAffinity holds details about calls to the GetCpuAffinity method.
		GetCpuAffinity []struct {
			// N is the n argument value.
			N int
		}
		// GetCpuAffinityWithinScope holds details about calls to the GetCpuAffinityWithinScope method.
		GetCpuAffinityWithinScope []struct {
			// N is the n argument value.
			N int
			// AffinityScope is the affinityScope argument value.
			AffinityScope nvml.AffinityScope
		}
		// GetCreatableVgpus holds details about calls to the GetCreatableVgpus method.
		GetCreatableVgpus []struct {
		}
		// GetCudaComputeCapability holds details about calls to the GetCudaComputeCapability method.
		GetCudaComputeCapability []struct {
		}
		// GetCurrPcieLinkGeneration holds details about calls to the GetCurrPcieLinkGeneration method.
		GetCurrPcieLinkGeneration []struct {
		}
		// GetCurrPcieLinkWidth holds details about calls to the GetCurrPcieLinkWidth method.
		GetCurrPcieLinkWidth []struct {
		}
		// GetCurrentClockFreqs holds details about calls to the GetCurrentClockFreqs method.
		GetCurrentClockFreqs []struct {
		}
		// GetCurrentClocksEventReasons holds details about calls to the GetCurrentClocksEventReasons method.
		GetCurrentClocksEventReasons []struct {
		}
		// GetCurrentClocksThrottleReasons holds details about calls to the GetCurrentClocksThrottleReasons method.
		GetCurrentClocksThrottleReasons []struct {
		}
		// GetDecoderUtilization holds details about calls to the GetDecoderUtilization method.
		GetDecoderUtilization []struct {
		}
		// GetDefaultApplicationsClock holds details about calls to the GetDefaultApplicationsClock method.
		GetDefaultApplicationsClock []struct {
			// ClockType is the clockType argument value.
			ClockType nvml.ClockType
		}
		// GetDefaultEccMode holds details about calls to the GetDefaultEccMode method.
		GetDefaultEccMode []struct {
		}
		// GetDetailedEccErrors holds details about calls to the GetDetailedEccErrors method.
		GetDetailedEccErrors []struct {
			// MemoryErrorType is the memoryErrorType argument value.
			MemoryErrorType nvml.MemoryErrorType
			// EccCounterType is the eccCounterType argument value.
			EccCounterType nvml.EccCounterType
		}
		// GetDeviceHandleFromMigDeviceHandle holds details about calls to the GetDeviceHandleFromMigDeviceHandle method.
		GetDeviceHandleFromMigDeviceHandle []struct {
		}
		// GetDisplayActive holds details about calls to the GetDisplayActive method.
		GetDisplayActive []struct {
		}
		// GetDisplayMode holds details about calls to the GetDisplayMode method.
		GetDisplayMode []struct {
		}
		// GetDramEncryptionMode holds details about calls to the GetDramEncryptionMode method.
		GetDramEncryptionMode []struct {
		}
		// GetDriverModel holds details about calls to the GetDriverModel method.
		GetDriverModel []struct {
		}
		// GetDriverModel_v2 holds details about calls to the GetDriverModel_v2 method.
		GetDriverModel_v2 []struct {
		}
		// GetDynamicPstatesInfo holds details about calls to the GetDynamicPstatesInfo method.
		GetDynamicPstatesInfo []struct {
		}
		// GetEccMode holds details about calls to the GetEccMode method.
		GetEccMode []struct {
		}
		// GetEncoderCapacity holds details about calls to the GetEncoderCapacity method.
		GetEncoderCapacity []struct {
			// EncoderType is the encoderType argument value.
			EncoderType nvml.EncoderType
		}
		// GetEncoderSessions holds details about calls to the GetEncoderSessions method.
		GetEncoderSessions []struct {
		}
		// GetEncoderStats holds details about calls to the GetEncoderStats method.
		GetEncoderStats []struct {
		}
		// GetEncoderUtilization holds details about calls to the GetEncoderUtilization method.
		GetEncoderUtilization []struct {
		}
		// GetEnforcedPowerLimit holds details about calls to the GetEnforcedPowerLimit method.
		GetEnforcedPowerLimit []struct {
		}
		// GetFBCSessions holds details about calls to the GetFBCSessions method.
		GetFBCSessions []struct {
		}
		// GetFBCStats holds details about calls to the GetFBCStats method.
		GetFBCStats []struct {
		}
		// GetFanControlPolicy_v2 holds details about calls to the GetFanControlPolicy_v2 method.
		GetFanControlPolicy_v2 []struct {
			// N is the n argument value.
			N int
		}
		// GetFanSpeed holds details about calls to the GetFanSpeed method.
		GetFanSpeed []struct {
		}
		// GetFanSpeedRPM holds details about calls to the GetFanSpeedRPM method.
		GetFanSpeedRPM []struct {
		}
		// GetFanSpeed_v2 holds details about calls to the GetFanSpeed_v2 method.
		GetFanSpeed_v2 []struct {
			// N is the n argument value.
			N int
		}
		// GetFieldValues holds details about calls to the GetFieldValues method.
		GetFieldValues []struct {
			// FieldValues is the fieldValues argument value.
			FieldValues []nvml.FieldValue
		}
		// GetGpcClkMinMaxVfOffset holds details about calls to the GetGpcClkMinMaxVfOffset method.
		GetGpcClkMinMaxVfOffset []struct {
		}
		// GetGpcClkVfOffset holds details about calls to the GetGpcClkVfOffset method.
		GetGpcClkVfOffset []struct {
		}
		// GetGpuFabricInfo holds details about calls to the GetGpuFabricInfo method.
		GetGpuFabricInfo []struct {
		}
		// GetGpuFabricInfoV holds details about calls to the GetGpuFabricInfoV method.
		GetGpuFabricInfoV []struct {
		}
		// GetGpuInstanceById holds details about calls to the GetGpuInstanceById method.
		GetGpuInstanceById []struct {
			// N is the n argument value.
			N int
		}
		// GetGpuInstanceId holds details about calls to the GetGpuInstanceId method.
		GetGpuInstanceId []struct {
		}
		// GetGpuInstancePossiblePlacements holds details about calls to the GetGpuInstancePossiblePlacements method.
		GetGpuInstancePossiblePlacements []struct {
			// GpuInstanceProfileInfo is the gpuInstanceProfileInfo argument value.
			GpuInstanceProfileInfo *nvml.GpuInstanceProfileInfo
		}
		// GetGpuInstanceProfileInfo holds details about calls to the GetGpuInstanceProfileInfo method.
		GetGpuInstanceProfileInfo []struct {
			// N is the n argument value.
			N int
		}
		// GetGpuInstanceProfileInfoByIdV holds details about calls to the GetGpuInstanceProfileInfoByIdV method.
		GetGpuInstanceProfileInfoByIdV []struct {
			// N is the n argument value.
			N int
		}
		// GetGpuInstanceProfileInfoV holds details about calls to the GetGpuInstanceProfileInfoV method.
		GetGpuInstanceProfileInfoV []struct {
			// N is the n argument value.
			N int
		}
		// GetGpuInstanceRemainingCapacity holds details about calls to the GetGpuInstanceRemainingCapacity method.
		GetGpuInstanceRemainingCapacity []struct {
			// GpuInstanceProfileInfo is the gpuInstanceProfileInfo argument value.
			GpuInstanceProfileInfo *nvml.GpuInstanceProfileInfo
		}
		// GetGpuInstances holds details about calls to the GetGpuInstances method.
		GetGpuInstances []struct {
			// GpuInstanceProfileInfo is the gpuInstanceProfileInfo argument value.
			GpuInstanceProfileInfo *nvml.GpuInstanceProfileInfo
		}
		// GetGpuMaxPcieLinkGeneration holds details about calls to the GetGpuMaxPcieLinkGeneration method.
		GetGpuMaxPcieLinkGeneration []struct {
		}
		// GetGpuOperationMode holds details about calls to the GetGpuOperationMode method.
		GetGpuOperationMode []struct {
		}
		// GetGraphicsRunningProcesses holds details about calls to the GetGraphicsRunningProcesses method.
		GetGraphicsRunningProcesses []struct {
		}
		// GetGridLicensableFeatures holds details about calls to the GetGridLicensableFeatures method.
		GetGridLicensableFeatures []struct {
		}
		// GetGspFirmwareMode holds details about calls to the GetGspFirmwareMode method.
		GetGspFirmwareMode []struct {
		}
		// GetGspFirmwareVersion holds details about calls to the GetGspFirmwareVersion method.
		GetGspFirmwareVersion []struct {
		}
		// GetHostVgpuMode holds details about calls to the GetHostVgpuMode method.
		GetHostVgpuMode []struct {
		}
		// GetIndex holds details about calls to the GetIndex method.
		GetIndex []struct {
		}
		// GetInforomConfigurationChecksum holds details about calls to the GetInforomConfigurationChecksum method.
		GetInforomConfigurationChecksum []struct {
		}
		// GetInforomImageVersion holds details about calls to the GetInforomImageVersion method.
		GetInforomImageVersion []struct {
		}
		// GetInforomVersion holds details about calls to the GetInforomVersion method.
		GetInforomVersion []struct {
			// InforomObject is the inforomObject argument value.
			InforomObject nvml.InforomObject
		}
		// GetIrqNum holds details about calls to the GetIrqNum method.
		GetIrqNum []struct {
		}
		// GetJpgUtilization holds details about calls to the GetJpgUtilization method.
		GetJpgUtilization []struct {
		}
		// GetLastBBXFlushTime holds details about calls to the GetLastBBXFlushTime method.
		GetLastBBXFlushTime []struct {
		}
		// GetMPSComputeRunningProcesses holds details about calls to the GetMPSComputeRunningProcesses method.
		GetMPSComputeRunningProcesses []struct {
		}
		// GetMarginTemperature holds details about calls to the GetMarginTemperature method.
		GetMarginTemperature []struct {
		}
		// GetMaxClockInfo holds details about calls to the GetMaxClockInfo method.
		GetMaxClockInfo []struct {
			// ClockType is the clockType argument value.
			ClockType nvml.ClockType
		}
		// GetMaxCustomerBoostClock holds details about calls to the GetMaxCustomerBoostClock method.
		GetMaxCustomerBoostClock []struct {
			// ClockType is the clockType argument value.
			ClockType nvml.ClockType
		}
		// GetMaxMigDeviceCount holds details about calls to the GetMaxMigDeviceCount method.
		GetMaxMigDeviceCount []struct {
		}
		// GetMaxPcieLinkGeneration holds details about calls to the GetMaxPcieLinkGeneration method.
		GetMaxPcieLinkGeneration []struct {
		}
		// GetMaxPcieLinkWidth holds details about calls to the GetMaxPcieLinkWidth method.
		GetMaxPcieLinkWidth []struct {
		}
		// GetMemClkMinMaxVfOffset holds details about calls to the GetMemClkMinMaxVfOffset method.
		GetMemClkMinMaxVfOffset []struct {
		}
		// GetMemClkVfOffset holds details about calls to the GetMemClkVfOffset method.
		GetMemClkVfOffset []struct {
		}
		// GetMemoryAffinity holds details about calls to the GetMemoryAffinity method.
		GetMemoryAffinity []struct {
			// N is the n argument value.
			N int
			// AffinityScope is the affinityScope argument value.
			AffinityScope nvml.AffinityScope
		}
		// GetMemoryBusWidth holds details about calls to the GetMemoryBusWidth method.
		GetMemoryBusWidth []struct {
		}
		// GetMemoryErrorCounter holds details about calls to the GetMemoryErrorCounter method.
		GetMemoryErrorCounter []struct {
			// 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
		}
		// GetMemoryInfo holds details about calls to the GetMemoryInfo method.
		GetMemoryInfo []struct {
		}
		// GetMemoryInfo_v2 holds details about calls to the GetMemoryInfo_v2 method.
		GetMemoryInfo_v2 []struct {
		}
		// GetMigDeviceHandleByIndex holds details about calls to the GetMigDeviceHandleByIndex method.
		GetMigDeviceHandleByIndex []struct {
			// N is the n argument value.
			N int
		}
		// GetMigMode holds details about calls to the GetMigMode method.
		GetMigMode []struct {
		}
		// GetMinMaxClockOfPState holds details about calls to the GetMinMaxClockOfPState method.
		GetMinMaxClockOfPState []struct {
			// ClockType is the clockType argument value.
			ClockType nvml.ClockType
			// Pstates is the pstates argument value.
			Pstates nvml.Pstates
		}
		// GetMinMaxFanSpeed holds details about calls to the GetMinMaxFanSpeed method.
		GetMinMaxFanSpeed []struct {
		}
		// GetMinorNumber holds details about calls to the GetMinorNumber method.
		GetMinorNumber []struct {
		}
		// GetModuleId holds details about calls to the GetModuleId method.
		GetModuleId []struct {
		}
		// GetMultiGpuBoard holds details about calls to the GetMultiGpuBoard method.
		GetMultiGpuBoard []struct {
		}
		// GetName holds details about calls to the GetName method.
		GetName []struct {
		}
		// GetNumFans holds details about calls to the GetNumFans method.
		GetNumFans []struct {
		}
		// GetNumGpuCores holds details about calls to the GetNumGpuCores method.
		GetNumGpuCores []struct {
		}
		// GetNumaNodeId holds details about calls to the GetNumaNodeId method.
		GetNumaNodeId []struct {
		}
		// GetNvLinkCapability holds details about calls to the GetNvLinkCapability method.
		GetNvLinkCapability []struct {
			// N is the n argument value.
			N int
			// NvLinkCapability is the nvLinkCapability argument value.
			NvLinkCapability nvml.NvLinkCapability
		}
		// GetNvLinkErrorCounter holds details about calls to the GetNvLinkErrorCounter method.
		GetNvLinkErrorCounter []struct {
			// N is the n argument value.
			N int
			// NvLinkErrorCounter is the nvLinkErrorCounter argument value.
			NvLinkErrorCounter nvml.NvLinkErrorCounter
		}
		// GetNvLinkInfo holds details about calls to the GetNvLinkInfo method.
		GetNvLinkInfo []struct {
		}
		// GetNvLinkRemoteDeviceType holds details about calls to the GetNvLinkRemoteDeviceType method.
		GetNvLinkRemoteDeviceType []struct {
			// N is the n argument value.
			N int
		}
		// GetNvLinkRemotePciInfo holds details about calls to the GetNvLinkRemotePciInfo method.
		GetNvLinkRemotePciInfo []struct {
			// N is the n argument value.
			N int
		}
		// GetNvLinkState holds details about calls to the GetNvLinkState method.
		GetNvLinkState []struct {
			// N is the n argument value.
			N int
		}
		// GetNvLinkUtilizationControl holds details about calls to the GetNvLinkUtilizationControl method.
		GetNvLinkUtilizationControl []struct {
			// N1 is the n1 argument value.
			N1 int
			// N2 is the n2 argument value.
			N2 int
		}
		// GetNvLinkUtilizationCounter holds details about calls to the GetNvLinkUtilizationCounter method.
		GetNvLinkUtilizationCounter []struct {
			// N1 is the n1 argument value.
			N1 int
			// N2 is the n2 argument value.
			N2 int
		}
		// GetNvLinkVersion holds details about calls to the GetNvLinkVersion method.
		GetNvLinkVersion []struct {
			// N is the n argument value.
			N int
		}
		// GetNvlinkBwMode holds details about calls to the GetNvlinkBwMode method.
		GetNvlinkBwMode []struct {
		}
		// GetNvlinkSupportedBwModes holds details about calls to the GetNvlinkSupportedBwModes method.
		GetNvlinkSupportedBwModes []struct {
		}
		// GetOfaUtilization holds details about calls to the GetOfaUtilization method.
		GetOfaUtilization []struct {
		}
		// GetP2PStatus holds details about calls to the GetP2PStatus method.
		GetP2PStatus []struct {
			// Device is the device argument value.
			Device nvml.Device
			// GpuP2PCapsIndex is the gpuP2PCapsIndex argument value.
			GpuP2PCapsIndex nvml.GpuP2PCapsIndex
		}
		// GetPciInfo holds details about calls to the GetPciInfo method.
		GetPciInfo []struct {
		}
		// GetPciInfoExt holds details about calls to the GetPciInfoExt method.
		GetPciInfoExt []struct {
		}
		// GetPcieLinkMaxSpeed holds details about calls to the GetPcieLinkMaxSpeed method.
		GetPcieLinkMaxSpeed []struct {
		}
		// GetPcieReplayCounter holds details about calls to the GetPcieReplayCounter method.
		GetPcieReplayCounter []struct {
		}
		// GetPcieSpeed holds details about calls to the GetPcieSpeed method.
		GetPcieSpeed []struct {
		}
		// GetPcieThroughput holds details about calls to the GetPcieThroughput method.
		GetPcieThroughput []struct {
			// PcieUtilCounter is the pcieUtilCounter argument value.
			PcieUtilCounter nvml.PcieUtilCounter
		}
		// GetPdi holds details about calls to the GetPdi method.
		GetPdi []struct {
		}
		// GetPerformanceModes holds details about calls to the GetPerformanceModes method.
		GetPerformanceModes []struct {
		}
		// GetPerformanceState holds details about calls to the GetPerformanceState method.
		GetPerformanceState []struct {
		}
		// GetPersistenceMode holds details about calls to the GetPersistenceMode method.
		GetPersistenceMode []struct {
		}
		// GetPgpuMetadataString holds details about calls to the GetPgpuMetadataString method.
		GetPgpuMetadataString []struct {
		}
		// GetPlatformInfo holds details about calls to the GetPlatformInfo method.
		GetPlatformInfo []struct {
		}
		// GetPowerManagementDefaultLimit holds details about calls to the GetPowerManagementDefaultLimit method.
		GetPowerManagementDefaultLimit []struct {
		}
		// GetPowerManagementLimit holds details about calls to the GetPowerManagementLimit method.
		GetPowerManagementLimit []struct {
		}
		// GetPowerManagementLimitConstraints holds details about calls to the GetPowerManagementLimitConstraints method.
		GetPowerManagementLimitConstraints []struct {
		}
		// GetPowerManagementMode holds details about calls to the GetPowerManagementMode method.
		GetPowerManagementMode []struct {
		}
		// GetPowerMizerMode_v1 holds details about calls to the GetPowerMizerMode_v1 method.
		GetPowerMizerMode_v1 []struct {
		}
		// GetPowerSource holds details about calls to the GetPowerSource method.
		GetPowerSource []struct {
		}
		// GetPowerState holds details about calls to the GetPowerState method.
		GetPowerState []struct {
		}
		// GetPowerUsage holds details about calls to the GetPowerUsage method.
		GetPowerUsage []struct {
		}
		// GetProcessUtilization holds details about calls to the GetProcessUtilization method.
		GetProcessUtilization []struct {
			// V is the v argument value.
			V uint64
		}
		// GetProcessesUtilizationInfo holds details about calls to the GetProcessesUtilizationInfo method.
		GetProcessesUtilizationInfo []struct {
		}
		// GetRemappedRows holds details about calls to the GetRemappedRows method.
		GetRemappedRows []struct {
		}
		// GetRepairStatus holds details about calls to the GetRepairStatus method.
		GetRepairStatus []struct {
		}
		// GetRetiredPages holds details about calls to the GetRetiredPages method.
		GetRetiredPages []struct {
			// PageRetirementCause is the pageRetirementCause argument value.
			PageRetirementCause nvml.PageRetirementCause
		}
		// GetRetiredPagesPendingStatus holds details about calls to the GetRetiredPagesPendingStatus method.
		GetRetiredPagesPendingStatus []struct {
		}
		// GetRetiredPages_v2 holds details about calls to the GetRetiredPages_v2 method.
		GetRetiredPages_v2 []struct {
			// PageRetirementCause is the pageRetirementCause argument value.
			PageRetirementCause nvml.PageRetirementCause
		}
		// GetRowRemapperHistogram holds details about calls to the GetRowRemapperHistogram method.
		GetRowRemapperHistogram []struct {
		}
		// GetRunningProcessDetailList holds details about calls to the GetRunningProcessDetailList method.
		GetRunningProcessDetailList []struct {
		}
		// GetSamples holds details about calls to the GetSamples method.
		GetSamples []struct {
			// SamplingType is the samplingType argument value.
			SamplingType nvml.SamplingType
			// V is the v argument value.
			V uint64
		}
		// GetSerial holds details about calls to the GetSerial method.
		GetSerial []struct {
		}
		// GetSramEccErrorStatus holds details about calls to the GetSramEccErrorStatus method.
		GetSramEccErrorStatus []struct {
		}
		// GetSramUniqueUncorrectedEccErrorCounts holds details about calls to the GetSramUniqueUncorrectedEccErrorCounts method.
		GetSramUniqueUncorrectedEccErrorCounts []struct {
			// EccSramUniqueUncorrectedErrorCounts is the eccSramUniqueUncorrectedErrorCounts argument value.
			EccSramUniqueUncorrectedErrorCounts *nvml.EccSramUniqueUncorrectedErrorCounts
		}
		// GetSupportedClocksEventReasons holds details about calls to the GetSupportedClocksEventReasons method.
		GetSupportedClocksEventReasons []struct {
		}
		// GetSupportedClocksThrottleReasons holds details about calls to the GetSupportedClocksThrottleReasons method.
		GetSupportedClocksThrottleReasons []struct {
		}
		// GetSupportedEventTypes holds details about calls to the GetSupportedEventTypes method.
		GetSupportedEventTypes []struct {
		}
		// GetSupportedGraphicsClocks holds details about calls to the GetSupportedGraphicsClocks method.
		GetSupportedGraphicsClocks []struct {
			// N is the n argument value.
			N int
		}
		// GetSupportedMemoryClocks holds details about calls to the GetSupportedMemoryClocks method.
		GetSupportedMemoryClocks []struct {
		}
		// GetSupportedPerformanceStates holds details about calls to the GetSupportedPerformanceStates method.
		GetSupportedPerformanceStates []struct {
		}
		// GetSupportedVgpus holds details about calls to the GetSupportedVgpus method.
		GetSupportedVgpus []struct {
		}
		// GetTargetFanSpeed holds details about calls to the GetTargetFanSpeed method.
		GetTargetFanSpeed []struct {
			// N is the n argument value.
			N int
		}
		// GetTemperature holds details about calls to the GetTemperature method.
		GetTemperature []struct {
			// TemperatureSensors is the temperatureSensors argument value.
			TemperatureSensors nvml.TemperatureSensors
		}
		// GetTemperatureThreshold holds details about calls to the GetTemperatureThreshold method.
		GetTemperatureThreshold []struct {
			// TemperatureThresholds is the temperatureThresholds argument value.
			TemperatureThresholds nvml.TemperatureThresholds
		}
		// GetTemperatureV holds details about calls to the GetTemperatureV method.
		GetTemperatureV []struct {
		}
		// GetThermalSettings holds details about calls to the GetThermalSettings method.
		GetThermalSettings []struct {
			// V is the v argument value.
			V uint32
		}
		// GetTopologyCommonAncestor holds details about calls to the GetTopologyCommonAncestor method.
		GetTopologyCommonAncestor []struct {
			// Device is the device argument value.
			Device nvml.Device
		}
		// GetTopologyNearestGpus holds details about calls to the GetTopologyNearestGpus method.
		GetTopologyNearestGpus []struct {
			// GpuTopologyLevel is the gpuTopologyLevel argument value.
			GpuTopologyLevel nvml.GpuTopologyLevel
		}
		// GetTotalEccErrors holds details about calls to the GetTotalEccErrors method.
		GetTotalEccErrors []struct {
			// MemoryErrorType is the memoryErrorType argument value.
			MemoryErrorType nvml.MemoryErrorType
			// EccCounterType is the eccCounterType argument value.
			EccCounterType nvml.EccCounterType
		}
		// GetTotalEnergyConsumption holds details about calls to the GetTotalEnergyConsumption method.
		GetTotalEnergyConsumption []struct {
		}
		// GetUUID holds details about calls to the GetUUID method.
		GetUUID []struct {
		}
		// GetUtilizationRates holds details about calls to the GetUtilizationRates method.
		GetUtilizationRates []struct {
		}
		// GetVbiosVersion holds details about calls to the GetVbiosVersion method.
		GetVbiosVersion []struct {
		}
		// GetVgpuCapabilities holds details about calls to the GetVgpuCapabilities method.
		GetVgpuCapabilities []struct {
			// DeviceVgpuCapability is the deviceVgpuCapability argument value.
			DeviceVgpuCapability nvml.DeviceVgpuCapability
		}
		// GetVgpuHeterogeneousMode holds details about calls to the GetVgpuHeterogeneousMode method.
		GetVgpuHeterogeneousMode []struct {
		}
		// GetVgpuInstancesUtilizationInfo holds details about calls to the GetVgpuInstancesUtilizationInfo method.
		GetVgpuInstancesUtilizationInfo []struct {
		}
		// GetVgpuMetadata holds details about calls to the GetVgpuMetadata method.
		GetVgpuMetadata []struct {
		}
		// GetVgpuProcessUtilization holds details about calls to the GetVgpuProcessUtilization method.
		GetVgpuProcessUtilization []struct {
			// V is the v argument value.
			V uint64
		}
		// GetVgpuProcessesUtilizationInfo holds details about calls to the GetVgpuProcessesUtilizationInfo method.
		GetVgpuProcessesUtilizationInfo []struct {
		}
		// GetVgpuSchedulerCapabilities holds details about calls to the GetVgpuSchedulerCapabilities method.
		GetVgpuSchedulerCapabilities []struct {
		}
		// GetVgpuSchedulerLog holds details about calls to the GetVgpuSchedulerLog method.
		GetVgpuSchedulerLog []struct {
		}
		// GetVgpuSchedulerState holds details about calls to the GetVgpuSchedulerState method.
		GetVgpuSchedulerState []struct {
		}
		// GetVgpuTypeCreatablePlacements holds details about calls to the GetVgpuTypeCreatablePlacements method.
		GetVgpuTypeCreatablePlacements []struct {
			// VgpuTypeId is the vgpuTypeId argument value.
			VgpuTypeId nvml.VgpuTypeId
		}
		// GetVgpuTypeSupportedPlacements holds details about calls to the GetVgpuTypeSupportedPlacements method.
		GetVgpuTypeSupportedPlacements []struct {
			// VgpuTypeId is the vgpuTypeId argument value.
			VgpuTypeId nvml.VgpuTypeId
		}
		// GetVgpuUtilization holds details about calls to the GetVgpuUtilization method.
		GetVgpuUtilization []struct {
			// V is the v argument value.
			V uint64
		}
		// GetViolationStatus holds details about calls to the GetViolationStatus method.
		GetViolationStatus []struct {
			// PerfPolicyType is the perfPolicyType argument value.
			PerfPolicyType nvml.PerfPolicyType
		}
		// GetVirtualizationMode holds details about calls to the GetVirtualizationMode method.
		GetVirtualizationMode []struct {
		}
		// GpmMigSampleGet holds details about calls to the GpmMigSampleGet method.
		GpmMigSampleGet []struct {
			// 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 {
		}
		// GpmQueryDeviceSupportV holds details about calls to the GpmQueryDeviceSupportV method.
		GpmQueryDeviceSupportV []struct {
		}
		// GpmQueryIfStreamingEnabled holds details about calls to the GpmQueryIfStreamingEnabled method.
		GpmQueryIfStreamingEnabled []struct {
		}
		// GpmSampleGet holds details about calls to the GpmSampleGet method.
		GpmSampleGet []struct {
			// GpmSample is the gpmSample argument value.
			GpmSample nvml.GpmSample
		}
		// GpmSetStreamingEnabled holds details about calls to the GpmSetStreamingEnabled method.
		GpmSetStreamingEnabled []struct {
			// V is the v argument value.
			V uint32
		}
		// IsMigDeviceHandle holds details about calls to the IsMigDeviceHandle method.
		IsMigDeviceHandle []struct {
		}
		// OnSameBoard holds details about calls to the OnSameBoard method.
		OnSameBoard []struct {
			// Device is the device argument value.
			Device nvml.Device
		}
		// PowerSmoothingActivatePresetProfile holds details about calls to the PowerSmoothingActivatePresetProfile method.
		PowerSmoothingActivatePresetProfile []struct {
			// PowerSmoothingProfile is the powerSmoothingProfile argument value.
			PowerSmoothingProfile *nvml.PowerSmoothingProfile
		}
		// PowerSmoothingSetState holds details about calls to the PowerSmoothingSetState method.
		PowerSmoothingSetState []struct {
			// PowerSmoothingState is the powerSmoothingState argument value.
			PowerSmoothingState *nvml.PowerSmoothingState
		}
		// PowerSmoothingUpdatePresetProfileParam holds details about calls to the PowerSmoothingUpdatePresetProfileParam method.
		PowerSmoothingUpdatePresetProfileParam []struct {
			// PowerSmoothingProfile is the powerSmoothingProfile argument value.
			PowerSmoothingProfile *nvml.PowerSmoothingProfile
		}
		// ReadWritePRM_v1 holds details about calls to the ReadWritePRM_v1 method.
		ReadWritePRM_v1 []struct {
			// PRMTLV_v1 is the pRMTLV_v1 argument value.
			PRMTLV_v1 *nvml.PRMTLV_v1
		}
		// RegisterEvents holds details about calls to the RegisterEvents method.
		RegisterEvents []struct {
			// V is the v argument value.
			V uint64
			// EventSet is the eventSet argument value.
			EventSet nvml.EventSet
		}
		// ResetApplicationsClocks holds details about calls to the ResetApplicationsClocks method.
		ResetApplicationsClocks []struct {
		}
		// ResetGpuLockedClocks holds details about calls to the ResetGpuLockedClocks method.
		ResetGpuLockedClocks []struct {
		}
		// ResetMemoryLockedClocks holds details about calls to the ResetMemoryLockedClocks method.
		ResetMemoryLockedClocks []struct {
		}
		// ResetNvLinkErrorCounters holds details about calls to the ResetNvLinkErrorCounters method.
		ResetNvLinkErrorCounters []struct {
			// N is the n argument value.
			N int
		}
		// ResetNvLinkUtilizationCounter holds details about calls to the ResetNvLinkUtilizationCounter method.
		ResetNvLinkUtilizationCounter []struct {
			// N1 is the n1 argument value.
			N1 int
			// N2 is the n2 argument value.
			N2 int
		}
		// SetAPIRestriction holds details about calls to the SetAPIRestriction method.
		SetAPIRestriction []struct {
			// RestrictedAPI is the restrictedAPI argument value.
			RestrictedAPI nvml.RestrictedAPI
			// EnableState is the enableState argument value.
			EnableState nvml.EnableState
		}
		// SetAccountingMode holds details about calls to the SetAccountingMode method.
		SetAccountingMode []struct {
			// EnableState is the enableState argument value.
			EnableState nvml.EnableState
		}
		// SetApplicationsClocks holds details about calls to the SetApplicationsClocks method.
		SetApplicationsClocks []struct {
			// V1 is the v1 argument value.
			V1 uint32
			// V2 is the v2 argument value.
			V2 uint32
		}
		// SetAutoBoostedClocksEnabled holds details about calls to the SetAutoBoostedClocksEnabled method.
		SetAutoBoostedClocksEnabled []struct {
			// EnableState is the enableState argument value.
			EnableState nvml.EnableState
		}
		// SetClockOffsets holds details about calls to the SetClockOffsets method.
		SetClockOffsets []struct {
			// ClockOffset is the clockOffset argument value.
			ClockOffset nvml.ClockOffset
		}
		// SetComputeMode holds details about calls to the SetComputeMode method.
		SetComputeMode []struct {
			// ComputeMode is the computeMode argument value.
			ComputeMode nvml.ComputeMode
		}
		// SetConfComputeUnprotectedMemSize holds details about calls to the SetConfComputeUnprotectedMemSize method.
		SetConfComputeUnprotectedMemSize []struct {
			// V is the v argument value.
			V uint64
		}
		// SetCpuAffinity holds details about calls to the SetCpuAffinity method.
		SetCpuAffinity []struct {
		}
		// SetDefaultAutoBoostedClocksEnabled holds details about calls to the SetDefaultAutoBoostedClocksEnabled method.
		SetDefaultAutoBoostedClocksEnabled []struct {
			// EnableState is the enableState argument value.
			EnableState nvml.EnableState
			// V is the v argument value.
			V uint32
		}
		// SetDefaultFanSpeed_v2 holds details about calls to the SetDefaultFanSpeed_v2 method.
		SetDefaultFanSpeed_v2 []struct {
			// N is the n argument value.
			N int
		}
		// SetDramEncryptionMode holds details about calls to the SetDramEncryptionMode method.
		SetDramEncryptionMode []struct {
			// DramEncryptionInfo is the dramEncryptionInfo argument value.
			DramEncryptionInfo *nvml.DramEncryptionInfo
		}
		// SetDriverModel holds details about calls to the SetDriverModel method.
		SetDriverModel []struct {
			// DriverModel is the driverModel argument value.
			DriverModel nvml.DriverModel
			// V is the v argument value.
			V uint32
		}
		// SetEccMode holds details about calls to the SetEccMode method.
		SetEccMode []struct {
			// EnableState is the enableState argument value.
			EnableState nvml.EnableState
		}
		// SetFanControlPolicy holds details about calls to the SetFanControlPolicy method.
		SetFanControlPolicy []struct {
			// N is the n argument value.
			N int
			// FanControlPolicy is the fanControlPolicy argument value.
			FanControlPolicy nvml.FanControlPolicy
		}
		// SetFanSpeed_v2 holds details about calls to the SetFanSpeed_v2 method.
		SetFanSpeed_v2 []struct {
			// N1 is the n1 argument value.
			N1 int
			// N2 is the n2 argument value.
			N2 int
		}
		// SetGpcClkVfOffset holds details about calls to the SetGpcClkVfOffset method.
		SetGpcClkVfOffset []struct {
			// N is the n argument value.
			N int
		}
		// SetGpuLockedClocks holds details about calls to the SetGpuLockedClocks method.
		SetGpuLockedClocks []struct {
			// V1 is the v1 argument value.
			V1 uint32
			// V2 is the v2 argument value.
			V2 uint32
		}
		// SetGpuOperationMode holds details about calls to the SetGpuOperationMode method.
		SetGpuOperationMode []struct {
			// GpuOperationMode is the gpuOperationMode argument value.
			GpuOperationMode nvml.GpuOperationMode
		}
		// SetMemClkVfOffset holds details about calls to the SetMemClkVfOffset method.
		SetMemClkVfOffset []struct {
			// N is the n argument value.
			N int
		}
		// SetMemoryLockedClocks holds details about calls to the SetMemoryLockedClocks method.
		SetMemoryLockedClocks []struct {
			// V1 is the v1 argument value.
			V1 uint32
			// V2 is the v2 argument value.
			V2 uint32
		}
		// SetMigMode holds details about calls to the SetMigMode method.
		SetMigMode []struct {
			// N is the n argument value.
			N int
		}
		// SetNvLinkDeviceLowPowerThreshold holds details about calls to the SetNvLinkDeviceLowPowerThreshold method.
		SetNvLinkDeviceLowPowerThreshold []struct {
			// NvLinkPowerThres is the nvLinkPowerThres argument value.
			NvLinkPowerThres *nvml.NvLinkPowerThres
		}
		// SetNvLinkUtilizationControl holds details about calls to the SetNvLinkUtilizationControl method.
		SetNvLinkUtilizationControl []struct {
			// 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
		}
		// SetNvlinkBwMode holds details about calls to the SetNvlinkBwMode method.
		SetNvlinkBwMode []struct {
			// NvlinkSetBwMode is the nvlinkSetBwMode argument value.
			NvlinkSetBwMode *nvml.NvlinkSetBwMode
		}
		// SetPersistenceMode holds details about calls to the SetPersistenceMode method.
		SetPersistenceMode []struct {
			// EnableState is the enableState argument value.
			EnableState nvml.EnableState
		}
		// SetPowerManagementLimit holds details about calls to the SetPowerManagementLimit method.
		SetPowerManagementLimit []struct {
			// V is the v argument value.
			V uint32
		}
		// SetPowerManagementLimit_v2 holds details about calls to the SetPowerManagementLimit_v2 method.
		SetPowerManagementLimit_v2 []struct {
			// PowerValue_v2 is the powerValue_v2 argument value.
			PowerValue_v2 *nvml.PowerValue_v2
		}
		// SetTemperatureThreshold holds details about calls to the SetTemperatureThreshold method.
		SetTemperatureThreshold []struct {
			// TemperatureThresholds is the temperatureThresholds argument value.
			TemperatureThresholds nvml.TemperatureThresholds
			// N is the n argument value.
			N int
		}
		// SetVgpuCapabilities holds details about calls to the SetVgpuCapabilities method.
		SetVgpuCapabilities []struct {
			// DeviceVgpuCapability is the deviceVgpuCapability argument value.
			DeviceVgpuCapability nvml.DeviceVgpuCapability
			// EnableState is the enableState argument value.
			EnableState nvml.EnableState
		}
		// SetVgpuHeterogeneousMode holds details about calls to the SetVgpuHeterogeneousMode method.
		SetVgpuHeterogeneousMode []struct {
			// VgpuHeterogeneousMode is the vgpuHeterogeneousMode argument value.
			VgpuHeterogeneousMode nvml.VgpuHeterogeneousMode
		}
		// SetVgpuSchedulerState holds details about calls to the SetVgpuSchedulerState method.
		SetVgpuSchedulerState []struct {
			// VgpuSchedulerSetState is the vgpuSchedulerSetState argument value.
			VgpuSchedulerSetState *nvml.VgpuSchedulerSetState
		}
		// SetVirtualizationMode holds details about calls to the SetVirtualizationMode method.
		SetVirtualizationMode []struct {
			// GpuVirtualizationMode is the gpuVirtualizationMode argument value.
			GpuVirtualizationMode nvml.GpuVirtualizationMode
		}
		// ValidateInforom holds details about calls to the ValidateInforom method.
		ValidateInforom []struct {
		}
		// VgpuTypeGetMaxInstances holds details about calls to the VgpuTypeGetMaxInstances method.
		VgpuTypeGetMaxInstances []struct {
			// VgpuTypeId is the vgpuTypeId argument value.
			VgpuTypeId nvml.VgpuTypeId
		}
		// WorkloadPowerProfileClearRequestedProfiles holds details about calls to the WorkloadPowerProfileClearRequestedProfiles method.
		WorkloadPowerProfileClearRequestedProfiles []struct {
			// WorkloadPowerProfileRequestedProfiles is the workloadPowerProfileRequestedProfiles argument value.
			WorkloadPowerProfileRequestedProfiles *nvml.WorkloadPowerProfileRequestedProfiles
		}
		// WorkloadPowerProfileGetCurrentProfiles holds details about calls to the WorkloadPowerProfileGetCurrentProfiles method.
		WorkloadPowerProfileGetCurrentProfiles []struct {
		}
		// WorkloadPowerProfileGetProfilesInfo holds details about calls to the WorkloadPowerProfileGetProfilesInfo method.
		WorkloadPowerProfileGetProfilesInfo []struct {
		}
		// WorkloadPowerProfileSetRequestedProfiles holds details about calls to the WorkloadPowerProfileSetRequestedProfiles method.
		WorkloadPowerProfileSetRequestedProfiles []struct {
			// WorkloadPowerProfileRequestedProfiles is the workloadPowerProfileRequestedProfiles argument value.
			WorkloadPowerProfileRequestedProfiles *nvml.WorkloadPowerProfileRequestedProfiles
		}
	}
	lockClearAccountingPids                        sync.RWMutex
	lockClearCpuAffinity                           sync.RWMutex
	lockClearEccErrorCounts                        sync.RWMutex
	lockClearFieldValues                           sync.RWMutex
	lockCreateGpuInstance                          sync.RWMutex
	lockCreateGpuInstanceWithPlacement             sync.RWMutex
	lockFreezeNvLinkUtilizationCounter             sync.RWMutex
	lockGetAPIRestriction                          sync.RWMutex
	lockGetAccountingBufferSize                    sync.RWMutex
	lockGetAccountingMode                          sync.RWMutex
	lockGetAccountingPids                          sync.RWMutex
	lockGetAccountingStats                         sync.RWMutex
	lockGetActiveVgpus                             sync.RWMutex
	lockGetAdaptiveClockInfoStatus                 sync.RWMutex
	lockGetAddressingMode                          sync.RWMutex
	lockGetApplicationsClock                       sync.RWMutex
	lockGetArchitecture                            sync.RWMutex
	lockGetAttributes                              sync.RWMutex
	lockGetAutoBoostedClocksEnabled                sync.RWMutex
	lockGetBAR1MemoryInfo                          sync.RWMutex
	lockGetBoardId                                 sync.RWMutex
	lockGetBoardPartNumber                         sync.RWMutex
	lockGetBrand                                   sync.RWMutex
	lockGetBridgeChipInfo                          sync.RWMutex
	lockGetBusType                                 sync.RWMutex
	lockGetC2cModeInfoV                            sync.RWMutex
	lockGetCapabilities                            sync.RWMutex
	lockGetClkMonStatus                            sync.RWMutex
	lockGetClock                                   sync.RWMutex
	lockGetClockInfo                               sync.RWMutex
	lockGetClockOffsets                            sync.RWMutex
	lockGetComputeInstanceId                       sync.RWMutex
	lockGetComputeMode                             sync.RWMutex
	lockGetComputeRunningProcesses                 sync.RWMutex
	lockGetConfComputeGpuAttestationReport         sync.RWMutex
	lockGetConfComputeGpuCertificate               sync.RWMutex
	lockGetConfComputeMemSizeInfo                  sync.RWMutex
	lockGetConfComputeProtectedMemoryUsage         sync.RWMutex
	lockGetCoolerInfo                              sync.RWMutex
	lockGetCpuAffinity                             sync.RWMutex
	lockGetCpuAffinityWithinScope                  sync.RWMutex
	lockGetCreatableVgpus                          sync.RWMutex
	lockGetCudaComputeCapability                   sync.RWMutex
	lockGetCurrPcieLinkGeneration                  sync.RWMutex
	lockGetCurrPcieLinkWidth                       sync.RWMutex
	lockGetCurrentClockFreqs                       sync.RWMutex
	lockGetCurrentClocksEventReasons               sync.RWMutex
	lockGetCurrentClocksThrottleReasons            sync.RWMutex
	lockGetDecoderUtilization                      sync.RWMutex
	lockGetDefaultApplicationsClock                sync.RWMutex
	lockGetDefaultEccMode                          sync.RWMutex
	lockGetDetailedEccErrors                       sync.RWMutex
	lockGetDeviceHandleFromMigDeviceHandle         sync.RWMutex
	lockGetDisplayActive                           sync.RWMutex
	lockGetDisplayMode                             sync.RWMutex
	lockGetDramEncryptionMode                      sync.RWMutex
	lockGetDriverModel                             sync.RWMutex
	lockGetDriverModel_v2                          sync.RWMutex
	lockGetDynamicPstatesInfo                      sync.RWMutex
	lockGetEccMode                                 sync.RWMutex
	lockGetEncoderCapacity                         sync.RWMutex
	lockGetEncoderSessions                         sync.RWMutex
	lockGetEncoderStats                            sync.RWMutex
	lockGetEncoderUtilization                      sync.RWMutex
	lockGetEnforcedPowerLimit                      sync.RWMutex
	lockGetFBCSessions                             sync.RWMutex
	lockGetFBCStats                                sync.RWMutex
	lockGetFanControlPolicy_v2                     sync.RWMutex
	lockGetFanSpeed                                sync.RWMutex
	lockGetFanSpeedRPM                             sync.RWMutex
	lockGetFanSpeed_v2                             sync.RWMutex
	lockGetFieldValues                             sync.RWMutex
	lockGetGpcClkMinMaxVfOffset                    sync.RWMutex
	lockGetGpcClkVfOffset                          sync.RWMutex
	lockGetGpuFabricInfo                           sync.RWMutex
	lockGetGpuFabricInfoV                          sync.RWMutex
	lockGetGpuInstanceById                         sync.RWMutex
	lockGetGpuInstanceId                           sync.RWMutex
	lockGetGpuInstancePossiblePlacements           sync.RWMutex
	lockGetGpuInstanceProfileInfo                  sync.RWMutex
	lockGetGpuInstanceProfileInfoByIdV             sync.RWMutex
	lockGetGpuInstanceProfileInfoV                 sync.RWMutex
	lockGetGpuInstanceRemainingCapacity            sync.RWMutex
	lockGetGpuInstances                            sync.RWMutex
	lockGetGpuMaxPcieLinkGeneration                sync.RWMutex
	lockGetGpuOperationMode                        sync.RWMutex
	lockGetGraphicsRunningProcesses                sync.RWMutex
	lockGetGridLicensableFeatures                  sync.RWMutex
	lockGetGspFirmwareMode                         sync.RWMutex
	lockGetGspFirmwareVersion                      sync.RWMutex
	lockGetHostVgpuMode                            sync.RWMutex
	lockGetIndex                                   sync.RWMutex
	lockGetInforomConfigurationChecksum            sync.RWMutex
	lockGetInforomImageVersion                     sync.RWMutex
	lockGetInforomVersion                          sync.RWMutex
	lockGetIrqNum                                  sync.RWMutex
	lockGetJpgUtilization                          sync.RWMutex
	lockGetLastBBXFlushTime                        sync.RWMutex
	lockGetMPSComputeRunningProcesses              sync.RWMutex
	lockGetMarginTemperature                       sync.RWMutex
	lockGetMaxClockInfo                            sync.RWMutex
	lockGetMaxCustomerBoostClock                   sync.RWMutex
	lockGetMaxMigDeviceCount                       sync.RWMutex
	lockGetMaxPcieLinkGeneration                   sync.RWMutex
	lockGetMaxPcieLinkWidth                        sync.RWMutex
	lockGetMemClkMinMaxVfOffset                    sync.RWMutex
	lockGetMemClkVfOffset                          sync.RWMutex
	lockGetMemoryAffinity                          sync.RWMutex
	lockGetMemoryBusWidth                          sync.RWMutex
	lockGetMemoryErrorCounter                      sync.RWMutex
	lockGetMemoryInfo                              sync.RWMutex
	lockGetMemoryInfo_v2                           sync.RWMutex
	lockGetMigDeviceHandleByIndex                  sync.RWMutex
	lockGetMigMode                                 sync.RWMutex
	lockGetMinMaxClockOfPState                     sync.RWMutex
	lockGetMinMaxFanSpeed                          sync.RWMutex
	lockGetMinorNumber                             sync.RWMutex
	lockGetModuleId                                sync.RWMutex
	lockGetMultiGpuBoard                           sync.RWMutex
	lockGetName                                    sync.RWMutex
	lockGetNumFans                                 sync.RWMutex
	lockGetNumGpuCores                             sync.RWMutex
	lockGetNumaNodeId                              sync.RWMutex
	lockGetNvLinkCapability                        sync.RWMutex
	lockGetNvLinkErrorCounter                      sync.RWMutex
	lockGetNvLinkInfo                              sync.RWMutex
	lockGetNvLinkRemoteDeviceType                  sync.RWMutex
	lockGetNvLinkRemotePciInfo                     sync.RWMutex
	lockGetNvLinkState                             sync.RWMutex
	lockGetNvLinkUtilizationControl                sync.RWMutex
	lockGetNvLinkUtilizationCounter                sync.RWMutex
	lockGetNvLinkVersion                           sync.RWMutex
	lockGetNvlinkBwMode                            sync.RWMutex
	lockGetNvlinkSupportedBwModes                  sync.RWMutex
	lockGetOfaUtilization                          sync.RWMutex
	lockGetP2PStatus                               sync.RWMutex
	lockGetPciInfo                                 sync.RWMutex
	lockGetPciInfoExt                              sync.RWMutex
	lockGetPcieLinkMaxSpeed                        sync.RWMutex
	lockGetPcieReplayCounter                       sync.RWMutex
	lockGetPcieSpeed                               sync.RWMutex
	lockGetPcieThroughput                          sync.RWMutex
	lockGetPdi                                     sync.RWMutex
	lockGetPerformanceModes                        sync.RWMutex
	lockGetPerformanceState                        sync.RWMutex
	lockGetPersistenceMode                         sync.RWMutex
	lockGetPgpuMetadataString                      sync.RWMutex
	lockGetPlatformInfo                            sync.RWMutex
	lockGetPowerManagementDefaultLimit             sync.RWMutex
	lockGetPowerManagementLimit                    sync.RWMutex
	lockGetPowerManagementLimitConstraints         sync.RWMutex
	lockGetPowerManagementMode                     sync.RWMutex
	lockGetPowerMizerMode_v1                       sync.RWMutex
	lockGetPowerSource                             sync.RWMutex
	lockGetPowerState                              sync.RWMutex
	lockGetPowerUsage                              sync.RWMutex
	lockGetProcessUtilization                      sync.RWMutex
	lockGetProcessesUtilizationInfo                sync.RWMutex
	lockGetRemappedRows                            sync.RWMutex
	lockGetRepairStatus                            sync.RWMutex
	lockGetRetiredPages                            sync.RWMutex
	lockGetRetiredPagesPendingStatus               sync.RWMutex
	lockGetRetiredPages_v2                         sync.RWMutex
	lockGetRowRemapperHistogram                    sync.RWMutex
	lockGetRunningProcessDetailList                sync.RWMutex
	lockGetSamples                                 sync.RWMutex
	lockGetSerial                                  sync.RWMutex
	lockGetSramEccErrorStatus                      sync.RWMutex
	lockGetSramUniqueUncorrectedEccErrorCounts     sync.RWMutex
	lockGetSupportedClocksEventReasons             sync.RWMutex
	lockGetSupportedClocksThrottleReasons          sync.RWMutex
	lockGetSupportedEventTypes                     sync.RWMutex
	lockGetSupportedGraphicsClocks                 sync.RWMutex
	lockGetSupportedMemoryClocks                   sync.RWMutex
	lockGetSupportedPerformanceStates              sync.RWMutex
	lockGetSupportedVgpus                          sync.RWMutex
	lockGetTargetFanSpeed                          sync.RWMutex
	lockGetTemperature                             sync.RWMutex
	lockGetTemperatureThreshold                    sync.RWMutex
	lockGetTemperatureV                            sync.RWMutex
	lockGetThermalSettings                         sync.RWMutex
	lockGetTopologyCommonAncestor                  sync.RWMutex
	lockGetTopologyNearestGpus                     sync.RWMutex
	lockGetTotalEccErrors                          sync.RWMutex
	lockGetTotalEnergyConsumption                  sync.RWMutex
	lockGetUUID                                    sync.RWMutex
	lockGetUtilizationRates                        sync.RWMutex
	lockGetVbiosVersion                            sync.RWMutex
	lockGetVgpuCapabilities                        sync.RWMutex
	lockGetVgpuHeterogeneousMode                   sync.RWMutex
	lockGetVgpuInstancesUtilizationInfo            sync.RWMutex
	lockGetVgpuMetadata                            sync.RWMutex
	lockGetVgpuProcessUtilization                  sync.RWMutex
	lockGetVgpuProcessesUtilizationInfo            sync.RWMutex
	lockGetVgpuSchedulerCapabilities               sync.RWMutex
	lockGetVgpuSchedulerLog                        sync.RWMutex
	lockGetVgpuSchedulerState                      sync.RWMutex
	lockGetVgpuTypeCreatablePlacements             sync.RWMutex
	lockGetVgpuTypeSupportedPlacements             sync.RWMutex
	lockGetVgpuUtilization                         sync.RWMutex
	lockGetViolationStatus                         sync.RWMutex
	lockGetVirtualizationMode                      sync.RWMutex
	lockGpmMigSampleGet                            sync.RWMutex
	lockGpmQueryDeviceSupport                      sync.RWMutex
	lockGpmQueryDeviceSupportV                     sync.RWMutex
	lockGpmQueryIfStreamingEnabled                 sync.RWMutex
	lockGpmSampleGet                               sync.RWMutex
	lockGpmSetStreamingEnabled                     sync.RWMutex
	lockIsMigDeviceHandle                          sync.RWMutex
	lockOnSameBoard                                sync.RWMutex
	lockPowerSmoothingActivatePresetProfile        sync.RWMutex
	lockPowerSmoothingSetState                     sync.RWMutex
	lockPowerSmoothingUpdatePresetProfileParam     sync.RWMutex
	lockReadWritePRM_v1                            sync.RWMutex
	lockRegisterEvents                             sync.RWMutex
	lockResetApplicationsClocks                    sync.RWMutex
	lockResetGpuLockedClocks                       sync.RWMutex
	lockResetMemoryLockedClocks                    sync.RWMutex
	lockResetNvLinkErrorCounters                   sync.RWMutex
	lockResetNvLinkUtilizationCounter              sync.RWMutex
	lockSetAPIRestriction                          sync.RWMutex
	lockSetAccountingMode                          sync.RWMutex
	lockSetApplicationsClocks                      sync.RWMutex
	lockSetAutoBoostedClocksEnabled                sync.RWMutex
	lockSetClockOffsets                            sync.RWMutex
	lockSetComputeMode                             sync.RWMutex
	lockSetConfComputeUnprotectedMemSize           sync.RWMutex
	lockSetCpuAffinity                             sync.RWMutex
	lockSetDefaultAutoBoostedClocksEnabled         sync.RWMutex
	lockSetDefaultFanSpeed_v2                      sync.RWMutex
	lockSetDramEncryptionMode                      sync.RWMutex
	lockSetDriverModel                             sync.RWMutex
	lockSetEccMode                                 sync.RWMutex
	lockSetFanControlPolicy                        sync.RWMutex
	lockSetFanSpeed_v2                             sync.RWMutex
	lockSetGpcClkVfOffset                          sync.RWMutex
	lockSetGpuLockedClocks                         sync.RWMutex
	lockSetGpuOperationMode                        sync.RWMutex
	lockSetMemClkVfOffset                          sync.RWMutex
	lockSetMemoryLockedClocks                      sync.RWMutex
	lockSetMigMode                                 sync.RWMutex
	lockSetNvLinkDeviceLowPowerThreshold           sync.RWMutex
	lockSetNvLinkUtilizationControl                sync.RWMutex
	lockSetNvlinkBwMode                            sync.RWMutex
	lockSetPersistenceMode                         sync.RWMutex
	lockSetPowerManagementLimit                    sync.RWMutex
	lockSetPowerManagementLimit_v2                 sync.RWMutex
	lockSetTemperatureThreshold                    sync.RWMutex
	lockSetVgpuCapabilities                        sync.RWMutex
	lockSetVgpuHeterogeneousMode                   sync.RWMutex
	lockSetVgpuSchedulerState                      sync.RWMutex
	lockSetVirtualizationMode                      sync.RWMutex
	lockValidateInforom                            sync.RWMutex
	lockVgpuTypeGetMaxInstances                    sync.RWMutex
	lockWorkloadPowerProfileClearRequestedProfiles sync.RWMutex
	lockWorkloadPowerProfileGetCurrentProfiles     sync.RWMutex
	lockWorkloadPowerProfileGetProfilesInfo        sync.RWMutex
	lockWorkloadPowerProfileSetRequestedProfiles   sync.RWMutex
}

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

// ClearAccountingPidsCalls gets all the calls that were made to ClearAccountingPids.
// Check the length with:
//
//	len(mockedDevice.ClearAccountingPidsCalls())
func (mock *Device) ClearAccountingPidsCalls() []struct {
} {
	var calls []struct {
	}
	mock.lockClearAccountingPids.RLock()
	calls = mock.calls.ClearAccountingPids
	mock.lockClearAccountingPids.RUnlock()
	return calls
}

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

// ClearCpuAffinityCalls gets all the calls that were made to ClearCpuAffinity.
// Check the length with:
//
//	len(mockedDevice.ClearCpuAffinityCalls())
func (mock *Device) ClearCpuAffinityCalls() []struct {
} {
	var calls []struct {
	}
	mock.lockClearCpuAffinity.RLock()
	calls = mock.calls.ClearCpuAffinity
	mock.lockClearCpuAffinity.RUnlock()
	return calls
}

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

// ClearEccErrorCountsCalls gets all the calls that were made to ClearEccErrorCounts.
// Check the length with:
//
//	len(mockedDevice.ClearEccErrorCountsCalls())
func (mock *Device) ClearEccErrorCountsCalls() []struct {
	EccCounterType nvml.EccCounterType
} {
	var calls []struct {
		EccCounterType nvml.EccCounterType
	}
	mock.lockClearEccErrorCounts.RLock()
	calls = mock.calls.ClearEccErrorCounts
	mock.lockClearEccErrorCounts.RUnlock()
	return calls
}

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

// ClearFieldValuesCalls gets all the calls that were made to ClearFieldValues.
// Check the length with:
//
//	len(mockedDevice.ClearFieldValuesCalls())
func (mock *Device) ClearFieldValuesCalls() []struct {
	FieldValues []nvml.FieldValue
} {
	var calls []struct {
		FieldValues []nvml.FieldValue
	}
	mock.lockClearFieldValues.RLock()
	calls = mock.calls.ClearFieldValues
	mock.lockClearFieldValues.RUnlock()
	return calls
}

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

// CreateGpuInstanceCalls gets all the calls that were made to CreateGpuInstance.
// Check the length with:
//
//	len(mockedDevice.CreateGpuInstanceCalls())
func (mock *Device) CreateGpuInstanceCalls() []struct {
	GpuInstanceProfileInfo *nvml.GpuInstanceProfileInfo
} {
	var calls []struct {
		GpuInstanceProfileInfo *nvml.GpuInstanceProfileInfo
	}
	mock.lockCreateGpuInstance.RLock()
	calls = mock.calls.CreateGpuInstance
	mock.lockCreateGpuInstance.RUnlock()
	return calls
}

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

// CreateGpuInstanceWithPlacementCalls gets all the calls that were made to CreateGpuInstanceWithPlacement.
// Check the length with:
//
//	len(mockedDevice.CreateGpuInstanceWithPlacementCalls())
func (mock *Device) CreateGpuInstanceWithPlacementCalls() []struct {
	GpuInstanceProfileInfo *nvml.GpuInstanceProfileInfo
	GpuInstancePlacement   *nvml.GpuInstancePlacement
} {
	var calls []struct {
		GpuInstanceProfileInfo *nvml.GpuInstanceProfileInfo
		GpuInstancePlacement   *nvml.GpuInstancePlacement
	}
	mock.lockCreateGpuInstanceWithPlacement.RLock()
	calls = mock.calls.CreateGpuInstanceWithPlacement
	mock.lockCreateGpuInstanceWithPlacement.RUnlock()
	return calls
}

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

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

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

// GetAPIRestrictionCalls gets all the calls that were made to GetAPIRestriction.
// Check the length with:
//
//	len(mockedDevice.GetAPIRestrictionCalls())
func (mock *Device) GetAPIRestrictionCalls() []struct {
	RestrictedAPI nvml.RestrictedAPI
} {
	var calls []struct {
		RestrictedAPI nvml.RestrictedAPI
	}
	mock.lockGetAPIRestriction.RLock()
	calls = mock.calls.GetAPIRestriction
	mock.lockGetAPIRestriction.RUnlock()
	return calls
}

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

// GetAccountingBufferSizeCalls gets all the calls that were made to GetAccountingBufferSize.
// Check the length with:
//
//	len(mockedDevice.GetAccountingBufferSizeCalls())
func (mock *Device) GetAccountingBufferSizeCalls() []struct {
} {
	var calls []struct {
	}
	mock.lockGetAccountingBufferSize.RLock()
	calls = mock.calls.GetAccountingBufferSize
	mock.lockGetAccountingBufferSize.RUnlock()
	return calls
}

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

// GetAccountingModeCalls gets all the calls that were made to GetAccountingMode.
// Check the length with:
//
//	len(mockedDevice.GetAccountingModeCalls())
func (mock *Device) GetAccountingModeCalls() []struct {
} {
	var calls []struct {
	}
	mock.lockGetAccountingMode.RLock()
	calls = mock.calls.GetAccountingMode
	mock.lockGetAccountingMode.RUnlock()
	return calls
}

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

// GetAccountingPidsCalls gets all the calls that were made to GetAccountingPids.
// Check the length with:
//
//	len(mockedDevice.GetAccountingPidsCalls())
func (mock *Device) GetAccountingPidsCalls() []struct {
} {
	var calls []struct {
	}
	mock.lockGetAccountingPids.RLock()
	calls = mock.calls.GetAccountingPids
	mock.lockGetAccountingPids.RUnlock()
	return calls
}

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

// GetAccountingStatsCalls gets all the calls that were made to GetAccountingStats.
// Check the length with:
//
//	len(mockedDevice.GetAccountingStatsCalls())
func (mock *Device) GetAccountingStatsCalls() []struct {
	V uint32
} {
	var calls []struct {
		V uint32
	}
	mock.lockGetAccountingStats.RLock()
	calls = mock.calls.GetAccountingStats
	mock.lockGetAccountingStats.RUnlock()
	return calls
}

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

// GetActiveVgpusCalls gets all the calls that were made to GetActiveVgpus.
// Check the length with:
//
//	len(mockedDevice.GetActiveVgpusCalls())
func (mock *Device) GetActiveVgpusCalls() []struct {
} {
	var calls []struct {
	}
	mock.lockGetActiveVgpus.RLock()
	calls = mock.calls.GetActiveVgpus
	mock.lockGetActiveVgpus.RUnlock()
	return calls
}

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

// GetAdaptiveClockInfoStatusCalls gets all the calls that were made to GetAdaptiveClockInfoStatus.
// Check the length with:
//
//	len(mockedDevice.GetAdaptiveClockInfoStatusCalls())
func (mock *Device) GetAdaptiveClockInfoStatusCalls() []struct {
} {
	var calls []struct {
	}
	mock.lockGetAdaptiveClockInfoStatus.RLock()
	calls = mock.calls.GetAdaptiveClockInfoStatus
	mock.lockGetAdaptiveClockInfoStatus.RUnlock()
	return calls
}

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

// GetAddressingModeCalls gets all the calls that were made to GetAddressingMode.
// Check the length with:
//
//	len(mockedDevice.GetAddressingModeCalls())
func (mock *Device) GetAddressingModeCalls() []struct {
} {
	var calls []struct {
	}
	mock.lockGetAddressingMode.RLock()
	calls = mock.calls.GetAddressingMode
	mock.lockGetAddressingMode.RUnlock()
	return calls
}

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

// GetApplicationsClockCalls gets all the calls that were made to GetApplicationsClock.
// Check the length with:
//
//	len(mockedDevice.GetApplicationsClockCalls())
func (mock *Device) GetApplicationsClockCalls() []struct {
	ClockType nvml.ClockType
} {
	var calls []struct {
		ClockType nvml.ClockType
	}
	mock.lockGetApplicationsClock.RLock()
	calls = mock.calls.GetApplicationsClock
	mock.lockGetApplicationsClock.RUnlock()
	return calls
}

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

// GetArchitectureCalls gets all the calls that were made to GetArchitecture.
// Check the length with:
//
//	len(mockedDevice.GetArchitectureCalls())
func (mock *Device) GetArchitectureCalls() []struct {
} {
	var calls []struct {
	}
	mock.lockGetArchitecture.RLock()
	calls = mock.calls.GetArchitecture
	mock.lockGetArchitecture.RUnlock()
	return calls
}

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

// GetAttributesCalls gets all the calls that were made to GetAttributes.
// Check the length with:
//
//	len(mockedDevice.GetAttributesCalls())
func (mock *Device) GetAttributesCalls() []struct {
} {
	var calls []struct {
	}
	mock.lockGetAttributes.RLock()
	calls = mock.calls.GetAttributes
	mock.lockGetAttributes.RUnlock()
	return calls
}

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

// GetAutoBoostedClocksEnabledCalls gets all the calls that were made to GetAutoBoostedClocksEnabled.
// Check the length with:
//
//	len(mockedDevice.GetAutoBoostedClocksEnabledCalls())
func (mock *Device) GetAutoBoostedClocksEnabledCalls() []struct {
} {
	var calls []struct {
	}
	mock.lockGetAutoBoostedClocksEnabled.RLock()
	calls = mock.calls.GetAutoBoostedClocksEnabled
	mock.lockGetAutoBoostedClocksEnabled.RUnlock()
	return calls
}

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

// GetBAR1MemoryInfoCalls gets all the calls that were made to GetBAR1MemoryInfo.
// Check the length with:
//
//	len(mockedDevice.GetBAR1MemoryInfoCalls())
func (mock *Device) GetBAR1MemoryInfoCalls() []struct {
} {
	var calls []struct {
	}
	mock.lockGetBAR1MemoryInfo.RLock()
	calls = mock.calls.GetBAR1MemoryInfo
	mock.lockGetBAR1MemoryInfo.RUnlock()
	return calls
}

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

// GetBoardIdCalls gets all the calls that were made to GetBoardId.
// Check the length with:
//
//	len(mockedDevice.GetBoardIdCalls())
func (mock *Device) GetBoardIdCalls() []struct {
} {
	var calls []struct {
	}
	mock.lockGetBoardId.RLock()
	calls = mock.calls.GetBoardId
	mock.lockGetBoardId.RUnlock()
	return calls
}

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

// GetBoardPartNumberCalls gets all the calls that were made to GetBoardPartNumber.
// Check the length with:
//
//	len(mockedDevice.GetBoardPartNumberCalls())
func (mock *Device) GetBoardPartNumberCalls() []struct {
} {
	var calls []struct {
	}
	mock.lockGetBoardPartNumber.RLock()
	calls = mock.calls.GetBoardPartNumber
	mock.lockGetBoardPartNumber.RUnlock()
	return calls
}

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

// GetBrandCalls gets all the calls that were made to GetBrand.
// Check the length with:
//
//	len(mockedDevice.GetBrandCalls())
func (mock *Device) GetBrandCalls() []struct {
} {
	var calls []struct {
	}
	mock.lockGetBrand.RLock()
	calls = mock.calls.GetBrand
	mock.lockGetBrand.RUnlock()
	return calls
}

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

// GetBridgeChipInfoCalls gets all the calls that were made to GetBridgeChipInfo.
// Check the length with:
//
//	len(mockedDevice.GetBridgeChipInfoCalls())
func (mock *Device) GetBridgeChipInfoCalls() []struct {
} {
	var calls []struct {
	}
	mock.lockGetBridgeChipInfo.RLock()
	calls = mock.calls.GetBridgeChipInfo
	mock.lockGetBridgeChipInfo.RUnlock()
	return calls
}

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

// GetBusTypeCalls gets all the calls that were made to GetBusType.
// Check the length with:
//
//	len(mockedDevice.GetBusTypeCalls())
func (mock *Device) GetBusTypeCalls() []struct {
} {
	var calls []struct {
	}
	mock.lockGetBusType.RLock()
	calls = mock.calls.GetBusType
	mock.lockGetBusType.RUnlock()
	return calls
}

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

// GetC2cModeInfoVCalls gets all the calls that were made to GetC2cModeInfoV.
// Check the length with:
//
//	len(mockedDevice.GetC2cModeInfoVCalls())
func (mock *Device) GetC2cModeInfoVCalls() []struct {
} {
	var calls []struct {
	}
	mock.lockGetC2cModeInfoV.RLock()
	calls = mock.calls.GetC2cModeInfoV
	mock.lockGetC2cModeInfoV.RUnlock()
	return calls
}

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

// GetCapabilitiesCalls gets all the calls that were made to GetCapabilities.
// Check the length with:
//
//	len(mockedDevice.GetCapabilitiesCalls())
func (mock *Device) GetCapabilitiesCalls() []struct {
} {
	var calls []struct {
	}
	mock.lockGetCapabilities.RLock()
	calls = mock.calls.GetCapabilities
	mock.lockGetCapabilities.RUnlock()
	return calls
}

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

// GetClkMonStatusCalls gets all the calls that were made to GetClkMonStatus.
// Check the length with:
//
//	len(mockedDevice.GetClkMonStatusCalls())
func (mock *Device) GetClkMonStatusCalls() []struct {
} {
	var calls []struct {
	}
	mock.lockGetClkMonStatus.RLock()
	calls = mock.calls.GetClkMonStatus
	mock.lockGetClkMonStatus.RUnlock()
	return calls
}

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

// GetClockCalls gets all the calls that were made to GetClock.
// Check the length with:
//
//	len(mockedDevice.GetClockCalls())
func (mock *Device) GetClockCalls() []struct {
	ClockType nvml.ClockType
	ClockId   nvml.ClockId
} {
	var calls []struct {
		ClockType nvml.ClockType
		ClockId   nvml.ClockId
	}
	mock.lockGetClock.RLock()
	calls = mock.calls.GetClock
	mock.lockGetClock.RUnlock()
	return calls
}

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

// GetClockInfoCalls gets all the calls that were made to GetClockInfo.
// Check the length with:
//
//	len(mockedDevice.GetClockInfoCalls())
func (mock *Device) GetClockInfoCalls() []struct {
	ClockType nvml.ClockType
} {
	var calls []struct {
		ClockType nvml.ClockType
	}
	mock.lockGetClockInfo.RLock()
	calls = mock.calls.GetClockInfo
	mock.lockGetClockInfo.RUnlock()
	return calls
}

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

// GetClockOffsetsCalls gets all the calls that were made to GetClockOffsets.
// Check the length with:
//
//	len(mockedDevice.GetClockOffsetsCalls())
func (mock *Device) GetClockOffsetsCalls() []struct {
} {
	var calls []struct {
	}
	mock.lockGetClockOffsets.RLock()
	calls = mock.calls.GetClockOffsets
	mock.lockGetClockOffsets.RUnlock()
	return calls
}

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

// GetComputeInstanceIdCalls gets all the calls that were made to GetComputeInstanceId.
// Check the length with:
//
//	len(mockedDevice.GetComputeInstanceIdCalls())
func (mock *Device) GetComputeInstanceIdCalls() []struct {
} {
	var calls []struct {
	}
	mock.lockGetComputeInstanceId.RLock()
	calls = mock.calls.GetComputeInstanceId
	mock.lockGetComputeInstanceId.RUnlock()
	return calls
}

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

// GetComputeModeCalls gets all the calls that were made to GetComputeMode.
// Check the length with:
//
//	len(mockedDevice.GetComputeModeCalls())
func (mock *Device) GetComputeModeCalls() []struct {
} {
	var calls []struct {
	}
	mock.lockGetComputeMode.RLock()
	calls = mock.calls.GetComputeMode
	mock.lockGetComputeMode.RUnlock()
	return calls
}

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

// GetComputeRunningProcessesCalls gets all the calls that were made to GetComputeRunningProcesses.
// Check the length with:
//
//	len(mockedDevice.GetComputeRunningProcessesCalls())
func (mock *Device) GetComputeRunningProcessesCalls() []struct {
} {
	var calls []struct {
	}
	mock.lockGetComputeRunningProcesses.RLock()
	calls = mock.calls.GetComputeRunningProcesses
	mock.lockGetComputeRunningProcesses.RUnlock()
	return calls
}

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

// GetConfComputeGpuAttestationReportCalls gets all the calls that were made to GetConfComputeGpuAttestationReport.
// Check the length with:
//
//	len(mockedDevice.GetConfComputeGpuAttestationReportCalls())
func (mock *Device) GetConfComputeGpuAttestationReportCalls() []struct {
	ConfComputeGpuAttestationReport *nvml.ConfComputeGpuAttestationReport
} {
	var calls []struct {
		ConfComputeGpuAttestationReport *nvml.ConfComputeGpuAttestationReport
	}
	mock.lockGetConfComputeGpuAttestationReport.RLock()
	calls = mock.calls.GetConfComputeGpuAttestationReport
	mock.lockGetConfComputeGpuAttestationReport.RUnlock()
	return calls
}

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

// GetConfComputeGpuCertificateCalls gets all the calls that were made to GetConfComputeGpuCertificate.
// Check the length with:
//
//	len(mockedDevice.GetConfComputeGpuCertificateCalls())
func (mock *Device) GetConfComputeGpuCertificateCalls() []struct {
} {
	var calls []struct {
	}
	mock.lockGetConfComputeGpuCertificate.RLock()
	calls = mock.calls.GetConfComputeGpuCertificate
	mock.lockGetConfComputeGpuCertificate.RUnlock()
	return calls
}

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

// GetConfComputeMemSizeInfoCalls gets all the calls that were made to GetConfComputeMemSizeInfo.
// Check the length with:
//
//	len(mockedDevice.GetConfComputeMemSizeInfoCalls())
func (mock *Device) GetConfComputeMemSizeInfoCalls() []struct {
} {
	var calls []struct {
	}
	mock.lockGetConfComputeMemSizeInfo.RLock()
	calls = mock.calls.GetConfComputeMemSizeInfo
	mock.lockGetConfComputeMemSizeInfo.RUnlock()
	return calls
}

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

// GetConfComputeProtectedMemoryUsageCalls gets all the calls that were made to GetConfComputeProtectedMemoryUsage.
// Check the length with:
//
//	len(mockedDevice.GetConfComputeProtectedMemoryUsageCalls())
func (mock *Device) GetConfComputeProtectedMemoryUsageCalls() []struct {
} {
	var calls []struct {
	}
	mock.lockGetConfComputeProtectedMemoryUsage.RLock()
	calls = mock.calls.GetConfComputeProtectedMemoryUsage
	mock.lockGetConfComputeProtectedMemoryUsage.RUnlock()
	return calls
}

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

// GetCoolerInfoCalls gets all the calls that were made to GetCoolerInfo.
// Check the length with:
//
//	len(mockedDevice.GetCoolerInfoCalls())
func (mock *Device) GetCoolerInfoCalls() []struct {
} {
	var calls []struct {
	}
	mock.lockGetCoolerInfo.RLock()
	calls = mock.calls.GetCoolerInfo
	mock.lockGetCoolerInfo.RUnlock()
	return calls
}

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

// GetCpuAffinityCalls gets all the calls that were made to GetCpuAffinity.
// Check the length with:
//
//	len(mockedDevice.GetCpuAffinityCalls())
func (mock *Device) GetCpuAffinityCalls() []struct {
	N int
} {
	var calls []struct {
		N int
	}
	mock.lockGetCpuAffinity.RLock()
	calls = mock.calls.GetCpuAffinity
	mock.lockGetCpuAffinity.RUnlock()
	return calls
}

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

// GetCpuAffinityWithinScopeCalls gets all the calls that were made to GetCpuAffinityWithinScope.
// Check the length with:
//
//	len(mockedDevice.GetCpuAffinityWithinScopeCalls())
func (mock *Device) GetCpuAffinityWithinScopeCalls() []struct {
	N             int
	AffinityScope nvml.AffinityScope
} {
	var calls []struct {
		N             int
		AffinityScope nvml.AffinityScope
	}
	mock.lockGetCpuAffinityWithinScope.RLock()
	calls = mock.calls.GetCpuAffinityWithinScope
	mock.lockGetCpuAffinityWithinScope.RUnlock()
	return calls
}

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

// GetCreatableVgpusCalls gets all the calls that were made to GetCreatableVgpus.
// Check the length with:
//
//	len(mockedDevice.GetCreatableVgpusCalls())
func (mock *Device) GetCreatableVgpusCalls() []struct {
} {
	var calls []struct {
	}
	mock.lockGetCreatableVgpus.RLock()
	calls = mock.calls.GetCreatableVgpus
	mock.lockGetCreatableVgpus.RUnlock()
	return calls
}

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

// GetCudaComputeCapabilityCalls gets all the calls that were made to GetCudaComputeCapability.
// Check the length with:
//
//	len(mockedDevice.GetCudaComputeCapabilityCalls())
func (mock *Device) GetCudaComputeCapabilityCalls() []struct {
} {
	var calls []struct {
	}
	mock.lockGetCudaComputeCapability.RLock()
	calls = mock.calls.GetCudaComputeCapability
	mock.lockGetCudaComputeCapability.RUnlock()
	return calls
}

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

// GetCurrPcieLinkGenerationCalls gets all the calls that were made to GetCurrPcieLinkGeneration.
// Check the length with:
//
//	len(mockedDevice.GetCurrPcieLinkGenerationCalls())
func (mock *Device) GetCurrPcieLinkGenerationCalls() []struct {
} {
	var calls []struct {
	}
	mock.lockGetCurrPcieLinkGeneration.RLock()
	calls = mock.calls.GetCurrPcieLinkGeneration
	mock.lockGetCurrPcieLinkGeneration.RUnlock()
	return calls
}

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

// GetCurrPcieLinkWidthCalls gets all the calls that were made to GetCurrPcieLinkWidth.
// Check the length with:
//
//	len(mockedDevice.GetCurrPcieLinkWidthCalls())
func (mock *Device) GetCurrPcieLinkWidthCalls() []struct {
} {
	var calls []struct {
	}
	mock.lockGetCurrPcieLinkWidth.RLock()
	calls = mock.calls.GetCurrPcieLinkWidth
	mock.lockGetCurrPcieLinkWidth.RUnlock()
	return calls
}

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

// GetCurrentClockFreqsCalls gets all the calls that were made to GetCurrentClockFreqs.
// Check the length with:
//
//	len(mockedDevice.GetCurrentClockFreqsCalls())
func (mock *Device) GetCurrentClockFreqsCalls() []struct {
} {
	var calls []struct {
	}
	mock.lockGetCurrentClockFreqs.RLock()
	calls = mock.calls.GetCurrentClockFreqs
	mock.lockGetCurrentClockFreqs.RUnlock()
	return calls
}

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

// GetCurrentClocksEventReasonsCalls gets all the calls that were made to GetCurrentClocksEventReasons.
// Check the length with:
//
//	len(mockedDevice.GetCurrentClocksEventReasonsCalls())
func (mock *Device) GetCurrentClocksEventReasonsCalls() []struct {
} {
	var calls []struct {
	}
	mock.lockGetCurrentClocksEventReasons.RLock()
	calls = mock.calls.GetCurrentClocksEventReasons
	mock.lockGetCurrentClocksEventReasons.RUnlock()
	return calls
}

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

// GetCurrentClocksThrottleReasonsCalls gets all the calls that were made to GetCurrentClocksThrottleReasons.
// Check the length with:
//
//	len(mockedDevice.GetCurrentClocksThrottleReasonsCalls())
func (mock *Device) GetCurrentClocksThrottleReasonsCalls() []struct {
} {
	var calls []struct {
	}
	mock.lockGetCurrentClocksThrottleReasons.RLock()
	calls = mock.calls.GetCurrentClocksThrottleReasons
	mock.lockGetCurrentClocksThrottleReasons.RUnlock()
	return calls
}

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

// GetDecoderUtilizationCalls gets all the calls that were made to GetDecoderUtilization.
// Check the length with:
//
//	len(mockedDevice.GetDecoderUtilizationCalls())
func (mock *Device) GetDecoderUtilizationCalls() []struct {
} {
	var calls []struct {
	}
	mock.lockGetDecoderUtilization.RLock()
	calls = mock.calls.GetDecoderUtilization
	mock.lockGetDecoderUtilization.RUnlock()
	return calls
}

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

// GetDefaultApplicationsClockCalls gets all the calls that were made to GetDefaultApplicationsClock.
// Check the length with:
//
//	len(mockedDevice.GetDefaultApplicationsClockCalls())
func (mock *Device) GetDefaultApplicationsClockCalls() []struct {
	ClockType nvml.ClockType
} {
	var calls []struct {
		ClockType nvml.ClockType
	}
	mock.lockGetDefaultApplicationsClock.RLock()
	calls = mock.calls.GetDefaultApplicationsClock
	mock.lockGetDefaultApplicationsClock.RUnlock()
	return calls
}

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

// GetDefaultEccModeCalls gets all the calls that were made to GetDefaultEccMode.
// Check the length with:
//
//	len(mockedDevice.GetDefaultEccModeCalls())
func (mock *Device) GetDefaultEccModeCalls() []struct {
} {
	var calls []struct {
	}
	mock.lockGetDefaultEccMode.RLock()
	calls = mock.calls.GetDefaultEccMode
	mock.lockGetDefaultEccMode.RUnlock()
	return calls
}

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

// GetDetailedEccErrorsCalls gets all the calls that were made to GetDetailedEccErrors.
// Check the length with:
//
//	len(mockedDevice.GetDetailedEccErrorsCalls())
func (mock *Device) GetDetailedEccErrorsCalls() []struct {
	MemoryErrorType nvml.MemoryErrorType
	EccCounterType  nvml.EccCounterType
} {
	var calls []struct {
		MemoryErrorType nvml.MemoryErrorType
		EccCounterType  nvml.EccCounterType
	}
	mock.lockGetDetailedEccErrors.RLock()
	calls = mock.calls.GetDetailedEccErrors
	mock.lockGetDetailedEccErrors.RUnlock()
	return calls
}

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

// GetDeviceHandleFromMigDeviceHandleCalls gets all the calls that were made to GetDeviceHandleFromMigDeviceHandle.
// Check the length with:
//
//	len(mockedDevice.GetDeviceHandleFromMigDeviceHandleCalls())
func (mock *Device) GetDeviceHandleFromMigDeviceHandleCalls() []struct {
} {
	var calls []struct {
	}
	mock.lockGetDeviceHandleFromMigDeviceHandle.RLock()
	calls = mock.calls.GetDeviceHandleFromMigDeviceHandle
	mock.lockGetDeviceHandleFromMigDeviceHandle.RUnlock()
	return calls
}

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

// GetDisplayActiveCalls gets all the calls that were made to GetDisplayActive.
// Check the length with:
//
//	len(mockedDevice.GetDisplayActiveCalls())
func (mock *Device) GetDisplayActiveCalls() []struct {
} {
	var calls []struct {
	}
	mock.lockGetDisplayActive.RLock()
	calls = mock.calls.GetDisplayActive
	mock.lockGetDisplayActive.RUnlock()
	return calls
}

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

// GetDisplayModeCalls gets all the calls that were made to GetDisplayMode.
// Check the length with:
//
//	len(mockedDevice.GetDisplayModeCalls())
func (mock *Device) GetDisplayModeCalls() []struct {
} {
	var calls []struct {
	}
	mock.lockGetDisplayMode.RLock()
	calls = mock.calls.GetDisplayMode
	mock.lockGetDisplayMode.RUnlock()
	return calls
}

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

// GetDramEncryptionModeCalls gets all the calls that were made to GetDramEncryptionMode.
// Check the length with:
//
//	len(mockedDevice.GetDramEncryptionModeCalls())
func (mock *Device) GetDramEncryptionModeCalls() []struct {
} {
	var calls []struct {
	}
	mock.lockGetDramEncryptionMode.RLock()
	calls = mock.calls.GetDramEncryptionMode
	mock.lockGetDramEncryptionMode.RUnlock()
	return calls
}

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

// GetDriverModelCalls gets all the calls that were made to GetDriverModel.
// Check the length with:
//
//	len(mockedDevice.GetDriverModelCalls())
func (mock *Device) GetDriverModelCalls() []struct {
} {
	var calls []struct {
	}
	mock.lockGetDriverModel.RLock()
	calls = mock.calls.GetDriverModel
	mock.lockGetDriverModel.RUnlock()
	return calls
}

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

// GetDriverModel_v2Calls gets all the calls that were made to GetDriverModel_v2.
// Check the length with:
//
//	len(mockedDevice.GetDriverModel_v2Calls())
func (mock *Device) GetDriverModel_v2Calls() []struct {
} {
	var calls []struct {
	}
	mock.lockGetDriverModel_v2.RLock()
	calls = mock.calls.GetDriverModel_v2
	mock.lockGetDriverModel_v2.RUnlock()
	return calls
}

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

// GetDynamicPstatesInfoCalls gets all the calls that were made to GetDynamicPstatesInfo.
// Check the length with:
//
//	len(mockedDevice.GetDynamicPstatesInfoCalls())
func (mock *Device) GetDynamicPstatesInfoCalls() []struct {
} {
	var calls []struct {
	}
	mock.lockGetDynamicPstatesInfo.RLock()
	calls = mock.calls.GetDynamicPstatesInfo
	mock.lockGetDynamicPstatesInfo.RUnlock()
	return calls
}

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

// GetEccModeCalls gets all the calls that were made to GetEccMode.
// Check the length with:
//
//	len(mockedDevice.GetEccModeCalls())
func (mock *Device) GetEccModeCalls() []struct {
} {
	var calls []struct {
	}
	mock.lockGetEccMode.RLock()
	calls = mock.calls.GetEccMode
	mock.lockGetEccMode.RUnlock()
	return calls
}

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

// GetEncoderCapacityCalls gets all the calls that were made to GetEncoderCapacity.
// Check the length with:
//
//	len(mockedDevice.GetEncoderCapacityCalls())
func (mock *Device) GetEncoderCapacityCalls() []struct {
	EncoderType nvml.EncoderType
} {
	var calls []struct {
		EncoderType nvml.EncoderType
	}
	mock.lockGetEncoderCapacity.RLock()
	calls = mock.calls.GetEncoderCapacity
	mock.lockGetEncoderCapacity.RUnlock()
	return calls
}

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

// GetEncoderSessionsCalls gets all the calls that were made to GetEncoderSessions.
// Check the length with:
//
//	len(mockedDevice.GetEncoderSessionsCalls())
func (mock *Device) GetEncoderSessionsCalls() []struct {
} {
	var calls []struct {
	}
	mock.lockGetEncoderSessions.RLock()
	calls = mock.calls.GetEncoderSessions
	mock.lockGetEncoderSessions.RUnlock()
	return calls
}

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

// GetEncoderStatsCalls gets all the calls that were made to GetEncoderStats.
// Check the length with:
//
//	len(mockedDevice.GetEncoderStatsCalls())
func (mock *Device) GetEncoderStatsCalls() []struct {
} {
	var calls []struct {
	}
	mock.lockGetEncoderStats.RLock()
	calls = mock.calls.GetEncoderStats
	mock.lockGetEncoderStats.RUnlock()
	return calls
}

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

// GetEncoderUtilizationCalls gets all the calls that were made to GetEncoderUtilization.
// Check the length with:
//
//	len(mockedDevice.GetEncoderUtilizationCalls())
func (mock *Device) GetEncoderUtilizationCalls() []struct {
} {
	var calls []struct {
	}
	mock.lockGetEncoderUtilization.RLock()
	calls = mock.calls.GetEncoderUtilization
	mock.lockGetEncoderUtilization.RUnlock()
	return calls
}

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

// GetEnforcedPowerLimitCalls gets all the calls that were made to GetEnforcedPowerLimit.
// Check the length with:
//
//	len(mockedDevice.GetEnforcedPowerLimitCalls())
func (mock *Device) GetEnforcedPowerLimitCalls() []struct {
} {
	var calls []struct {
	}
	mock.lockGetEnforcedPowerLimit.RLock()
	calls = mock.calls.GetEnforcedPowerLimit
	mock.lockGetEnforcedPowerLimit.RUnlock()
	return calls
}

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

// GetFBCSessionsCalls gets all the calls that were made to GetFBCSessions.
// Check the length with:
//
//	len(mockedDevice.GetFBCSessionsCalls())
func (mock *Device) GetFBCSessionsCalls() []struct {
} {
	var calls []struct {
	}
	mock.lockGetFBCSessions.RLock()
	calls = mock.calls.GetFBCSessions
	mock.lockGetFBCSessions.RUnlock()
	return calls
}

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

// GetFBCStatsCalls gets all the calls that were made to GetFBCStats.
// Check the length with:
//
//	len(mockedDevice.GetFBCStatsCalls())
func (mock *Device) GetFBCStatsCalls() []struct {
} {
	var calls []struct {
	}
	mock.lockGetFBCStats.RLock()
	calls = mock.calls.GetFBCStats
	mock.lockGetFBCStats.RUnlock()
	return calls
}

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

// GetFanControlPolicy_v2Calls gets all the calls that were made to GetFanControlPolicy_v2.
// Check the length with:
//
//	len(mockedDevice.GetFanControlPolicy_v2Calls())
func (mock *Device) GetFanControlPolicy_v2Calls() []struct {
	N int
} {
	var calls []struct {
		N int
	}
	mock.lockGetFanControlPolicy_v2.RLock()
	calls = mock.calls.GetFanControlPolicy_v2
	mock.lockGetFanControlPolicy_v2.RUnlock()
	return calls
}

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

// GetFanSpeedCalls gets all the calls that were made to GetFanSpeed.
// Check the length with:
//
//	len(mockedDevice.GetFanSpeedCalls())
func (mock *Device) GetFanSpeedCalls() []struct {
} {
	var calls []struct {
	}
	mock.lockGetFanSpeed.RLock()
	calls = mock.calls.GetFanSpeed
	mock.lockGetFanSpeed.RUnlock()
	return calls
}

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

// GetFanSpeedRPMCalls gets all the calls that were made to GetFanSpeedRPM.
// Check the length with:
//
//	len(mockedDevice.GetFanSpeedRPMCalls())
func (mock *Device) GetFanSpeedRPMCalls() []struct {
} {
	var calls []struct {
	}
	mock.lockGetFanSpeedRPM.RLock()
	calls = mock.calls.GetFanSpeedRPM
	mock.lockGetFanSpeedRPM.RUnlock()
	return calls
}

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

// GetFanSpeed_v2Calls gets all the calls that were made to GetFanSpeed_v2.
// Check the length with:
//
//	len(mockedDevice.GetFanSpeed_v2Calls())
func (mock *Device) GetFanSpeed_v2Calls() []struct {
	N int
} {
	var calls []struct {
		N int
	}
	mock.lockGetFanSpeed_v2.RLock()
	calls = mock.calls.GetFanSpeed_v2
	mock.lockGetFanSpeed_v2.RUnlock()
	return calls
}

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

// GetFieldValuesCalls gets all the calls that were made to GetFieldValues.
// Check the length with:
//
//	len(mockedDevice.GetFieldValuesCalls())
func (mock *Device) GetFieldValuesCalls() []struct {
	FieldValues []nvml.FieldValue
} {
	var calls []struct {
		FieldValues []nvml.FieldValue
	}
	mock.lockGetFieldValues.RLock()
	calls = mock.calls.GetFieldValues
	mock.lockGetFieldValues.RUnlock()
	return calls
}

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

// GetGpcClkMinMaxVfOffsetCalls gets all the calls that were made to GetGpcClkMinMaxVfOffset.
// Check the length with:
//
//	len(mockedDevice.GetGpcClkMinMaxVfOffsetCalls())
func (mock *Device) GetGpcClkMinMaxVfOffsetCalls() []struct {
} {
	var calls []struct {
	}
	mock.lockGetGpcClkMinMaxVfOffset.RLock()
	calls = mock.calls.GetGpcClkMinMaxVfOffset
	mock.lockGetGpcClkMinMaxVfOffset.RUnlock()
	return calls
}

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

// GetGpcClkVfOffsetCalls gets all the calls that were made to GetGpcClkVfOffset.
// Check the length with:
//
//	len(mockedDevice.GetGpcClkVfOffsetCalls())
func (mock *Device) GetGpcClkVfOffsetCalls() []struct {
} {
	var calls []struct {
	}
	mock.lockGetGpcClkVfOffset.RLock()
	calls = mock.calls.GetGpcClkVfOffset
	mock.lockGetGpcClkVfOffset.RUnlock()
	return calls
}

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

// GetGpuFabricInfoCalls gets all the calls that were made to GetGpuFabricInfo.
// Check the length with:
//
//	len(mockedDevice.GetGpuFabricInfoCalls())
func (mock *Device) GetGpuFabricInfoCalls() []struct {
} {
	var calls []struct {
	}
	mock.lockGetGpuFabricInfo.RLock()
	calls = mock.calls.GetGpuFabricInfo
	mock.lockGetGpuFabricInfo.RUnlock()
	return calls
}

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

// GetGpuFabricInfoVCalls gets all the calls that were made to GetGpuFabricInfoV.
// Check the length with:
//
//	len(mockedDevice.GetGpuFabricInfoVCalls())
func (mock *Device) GetGpuFabricInfoVCalls() []struct {
} {
	var calls []struct {
	}
	mock.lockGetGpuFabricInfoV.RLock()
	calls = mock.calls.GetGpuFabricInfoV
	mock.lockGetGpuFabricInfoV.RUnlock()
	return calls
}

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

// GetGpuInstanceByIdCalls gets all the calls that were made to GetGpuInstanceById.
// Check the length with:
//
//	len(mockedDevice.GetGpuInstanceByIdCalls())
func (mock *Device) GetGpuInstanceByIdCalls() []struct {
	N int
} {
	var calls []struct {
		N int
	}
	mock.lockGetGpuInstanceById.RLock()
	calls = mock.calls.GetGpuInstanceById
	mock.lockGetGpuInstanceById.RUnlock()
	return calls
}

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

// GetGpuInstanceIdCalls gets all the calls that were made to GetGpuInstanceId.
// Check the length with:
//
//	len(mockedDevice.GetGpuInstanceIdCalls())
func (mock *Device) GetGpuInstanceIdCalls() []struct {
} {
	var calls []struct {
	}
	mock.lockGetGpuInstanceId.RLock()
	calls = mock.calls.GetGpuInstanceId
	mock.lockGetGpuInstanceId.RUnlock()
	return calls
}

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

// GetGpuInstancePossiblePlacementsCalls gets all the calls that were made to GetGpuInstancePossiblePlacements.
// Check the length with:
//
//	len(mockedDevice.GetGpuInstancePossiblePlacementsCalls())
func (mock *Device) GetGpuInstancePossiblePlacementsCalls() []struct {
	GpuInstanceProfileInfo *nvml.GpuInstanceProfileInfo
} {
	var calls []struct {
		GpuInstanceProfileInfo *nvml.GpuInstanceProfileInfo
	}
	mock.lockGetGpuInstancePossiblePlacements.RLock()
	calls = mock.calls.GetGpuInstancePossiblePlacements
	mock.lockGetGpuInstancePossiblePlacements.RUnlock()
	return calls
}

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

// GetGpuInstanceProfileInfoCalls gets all the calls that were made to GetGpuInstanceProfileInfo.
// Check the length with:
//
//	len(mockedDevice.GetGpuInstanceProfileInfoCalls())
func (mock *Device) GetGpuInstanceProfileInfoCalls() []struct {
	N int
} {
	var calls []struct {
		N int
	}
	mock.lockGetGpuInstanceProfileInfo.RLock()
	calls = mock.calls.GetGpuInstanceProfileInfo
	mock.lockGetGpuInstanceProfileInfo.RUnlock()
	return calls
}

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

// GetGpuInstanceProfileInfoByIdVCalls gets all the calls that were made to GetGpuInstanceProfileInfoByIdV.
// Check the length with:
//
//	len(mockedDevice.GetGpuInstanceProfileInfoByIdVCalls())
func (mock *Device) GetGpuInstanceProfileInfoByIdVCalls() []struct {
	N int
} {
	var calls []struct {
		N int
	}
	mock.lockGetGpuInstanceProfileInfoByIdV.RLock()
	calls = mock.calls.GetGpuInstanceProfileInfoByIdV
	mock.lockGetGpuInstanceProfileInfoByIdV.RUnlock()
	return calls
}

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

// GetGpuInstanceProfileInfoVCalls gets all the calls that were made to GetGpuInstanceProfileInfoV.
// Check the length with:
//
//	len(mockedDevice.GetGpuInstanceProfileInfoVCalls())
func (mock *Device) GetGpuInstanceProfileInfoVCalls() []struct {
	N int
} {
	var calls []struct {
		N int
	}
	mock.lockGetGpuInstanceProfileInfoV.RLock()
	calls = mock.calls.GetGpuInstanceProfileInfoV
	mock.lockGetGpuInstanceProfileInfoV.RUnlock()
	return calls
}

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

// GetGpuInstanceRemainingCapacityCalls gets all the calls that were made to GetGpuInstanceRemainingCapacity.
// Check the length with:
//
//	len(mockedDevice.GetGpuInstanceRemainingCapacityCalls())
func (mock *Device) GetGpuInstanceRemainingCapacityCalls() []struct {
	GpuInstanceProfileInfo *nvml.GpuInstanceProfileInfo
} {
	var calls []struct {
		GpuInstanceProfileInfo *nvml.GpuInstanceProfileInfo
	}
	mock.lockGetGpuInstanceRemainingCapacity.RLock()
	calls = mock.calls.GetGpuInstanceRemainingCapacity
	mock.lockGetGpuInstanceRemainingCapacity.RUnlock()
	return calls
}

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

// GetGpuInstancesCalls gets all the calls that were made to GetGpuInstances.
// Check the length with:
//
//	len(mockedDevice.GetGpuInstancesCalls())
func (mock *Device) GetGpuInstancesCalls() []struct {
	GpuInstanceProfileInfo *nvml.GpuInstanceProfileInfo
} {
	var calls []struct {
		GpuInstanceProfileInfo *nvml.GpuInstanceProfileInfo
	}
	mock.lockGetGpuInstances.RLock()
	calls = mock.calls.GetGpuInstances
	mock.lockGetGpuInstances.RUnlock()
	return calls
}

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

// GetGpuMaxPcieLinkGenerationCalls gets all the calls that were made to GetGpuMaxPcieLinkGeneration.
// Check the length with:
//
//	len(mockedDevice.GetGpuMaxPcieLinkGenerationCalls())
func (mock *Device) GetGpuMaxPcieLinkGenerationCalls() []struct {
} {
	var calls []struct {
	}
	mock.lockGetGpuMaxPcieLinkGeneration.RLock()
	calls = mock.calls.GetGpuMaxPcieLinkGeneration
	mock.lockGetGpuMaxPcieLinkGeneration.RUnlock()
	return calls
}

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

// GetGpuOperationModeCalls gets all the calls that were made to GetGpuOperationMode.
// Check the length with:
//
//	len(mockedDevice.GetGpuOperationModeCalls())
func (mock *Device) GetGpuOperationModeCalls() []struct {
} {
	var calls []struct {
	}
	mock.lockGetGpuOperationMode.RLock()
	calls = mock.calls.GetGpuOperationMode
	mock.lockGetGpuOperationMode.RUnlock()
	return calls
}

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

// GetGraphicsRunningProcessesCalls gets all the calls that were made to GetGraphicsRunningProcesses.
// Check the length with:
//
//	len(mockedDevice.GetGraphicsRunningProcessesCalls())
func (mock *Device) GetGraphicsRunningProcessesCalls() []struct {
} {
	var calls []struct {
	}
	mock.lockGetGraphicsRunningProcesses.RLock()
	calls = mock.calls.GetGraphicsRunningProcesses
	mock.lockGetGraphicsRunningProcesses.RUnlock()
	return calls
}

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

// GetGridLicensableFeaturesCalls gets all the calls that were made to GetGridLicensableFeatures.
// Check the length with:
//
//	len(mockedDevice.GetGridLicensableFeaturesCalls())
func (mock *Device) GetGridLicensableFeaturesCalls() []struct {
} {
	var calls []struct {
	}
	mock.lockGetGridLicensableFeatures.RLock()
	calls = mock.calls.GetGridLicensableFeatures
	mock.lockGetGridLicensableFeatures.RUnlock()
	return calls
}

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

// GetGspFirmwareModeCalls gets all the calls that were made to GetGspFirmwareMode.
// Check the length with:
//
//	len(mockedDevice.GetGspFirmwareModeCalls())
func (mock *Device) GetGspFirmwareModeCalls() []struct {
} {
	var calls []struct {
	}
	mock.lockGetGspFirmwareMode.RLock()
	calls = mock.calls.GetGspFirmwareMode
	mock.lockGetGspFirmwareMode.RUnlock()
	return calls
}

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

// GetGspFirmwareVersionCalls gets all the calls that were made to GetGspFirmwareVersion.
// Check the length with:
//
//	len(mockedDevice.GetGspFirmwareVersionCalls())
func (mock *Device) GetGspFirmwareVersionCalls() []struct {
} {
	var calls []struct {
	}
	mock.lockGetGspFirmwareVersion.RLock()
	calls = mock.calls.GetGspFirmwareVersion
	mock.lockGetGspFirmwareVersion.RUnlock()
	return calls
}

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

// GetHostVgpuModeCalls gets all the calls that were made to GetHostVgpuMode.
// Check the length with:
//
//	len(mockedDevice.GetHostVgpuModeCalls())
func (mock *Device) GetHostVgpuModeCalls() []struct {
} {
	var calls []struct {
	}
	mock.lockGetHostVgpuMode.RLock()
	calls = mock.calls.GetHostVgpuMode
	mock.lockGetHostVgpuMode.RUnlock()
	return calls
}

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

// GetIndexCalls gets all the calls that were made to GetIndex.
// Check the length with:
//
//	len(mockedDevice.GetIndexCalls())
func (mock *Device) GetIndexCalls() []struct {
} {
	var calls []struct {
	}
	mock.lockGetIndex.RLock()
	calls = mock.calls.GetIndex
	mock.lockGetIndex.RUnlock()
	return calls
}

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

// GetInforomConfigurationChecksumCalls gets all the calls that were made to GetInforomConfigurationChecksum.
// Check the length with:
//
//	len(mockedDevice.GetInforomConfigurationChecksumCalls())
func (mock *Device) GetInforomConfigurationChecksumCalls() []struct {
} {
	var calls []struct {
	}
	mock.lockGetInforomConfigurationChecksum.RLock()
	calls = mock.calls.GetInforomConfigurationChecksum
	mock.lockGetInforomConfigurationChecksum.RUnlock()
	return calls
}

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

// GetInforomImageVersionCalls gets all the calls that were made to GetInforomImageVersion.
// Check the length with:
//
//	len(mockedDevice.GetInforomImageVersionCalls())
func (mock *Device) GetInforomImageVersionCalls() []struct {
} {
	var calls []struct {
	}
	mock.lockGetInforomImageVersion.RLock()
	calls = mock.calls.GetInforomImageVersion
	mock.lockGetInforomImageVersion.RUnlock()
	return calls
}

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

// GetInforomVersionCalls gets all the calls that were made to GetInforomVersion.
// Check the length with:
//
//	len(mockedDevice.GetInforomVersionCalls())
func (mock *Device) GetInforomVersionCalls() []struct {
	InforomObject nvml.InforomObject
} {
	var calls []struct {
		InforomObject nvml.InforomObject
	}
	mock.lockGetInforomVersion.RLock()
	calls = mock.calls.GetInforomVersion
	mock.lockGetInforomVersion.RUnlock()
	return calls
}

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

// GetIrqNumCalls gets all the calls that were made to GetIrqNum.
// Check the length with:
//
//	len(mockedDevice.GetIrqNumCalls())
func (mock *Device) GetIrqNumCalls() []struct {
} {
	var calls []struct {
	}
	mock.lockGetIrqNum.RLock()
	calls = mock.calls.GetIrqNum
	mock.lockGetIrqNum.RUnlock()
	return calls
}

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

// GetJpgUtilizationCalls gets all the calls that were made to GetJpgUtilization.
// Check the length with:
//
//	len(mockedDevice.GetJpgUtilizationCalls())
func (mock *Device) GetJpgUtilizationCalls() []struct {
} {
	var calls []struct {
	}
	mock.lockGetJpgUtilization.RLock()
	calls = mock.calls.GetJpgUtilization
	mock.lockGetJpgUtilization.RUnlock()
	return calls
}

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

// GetLastBBXFlushTimeCalls gets all the calls that were made to GetLastBBXFlushTime.
// Check the length with:
//
//	len(mockedDevice.GetLastBBXFlushTimeCalls())
func (mock *Device) GetLastBBXFlushTimeCalls() []struct {
} {
	var calls []struct {
	}
	mock.lockGetLastBBXFlushTime.RLock()
	calls = mock.calls.GetLastBBXFlushTime
	mock.lockGetLastBBXFlushTime.RUnlock()
	return calls
}

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

// GetMPSComputeRunningProcessesCalls gets all the calls that were made to GetMPSComputeRunningProcesses.
// Check the length with:
//
//	len(mockedDevice.GetMPSComputeRunningProcessesCalls())
func (mock *Device) GetMPSComputeRunningProcessesCalls() []struct {
} {
	var calls []struct {
	}
	mock.lockGetMPSComputeRunningProcesses.RLock()
	calls = mock.calls.GetMPSComputeRunningProcesses
	mock.lockGetMPSComputeRunningProcesses.RUnlock()
	return calls
}

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

// GetMarginTemperatureCalls gets all the calls that were made to GetMarginTemperature.
// Check the length with:
//
//	len(mockedDevice.GetMarginTemperatureCalls())
func (mock *Device) GetMarginTemperatureCalls() []struct {
} {
	var calls []struct {
	}
	mock.lockGetMarginTemperature.RLock()
	calls = mock.calls.GetMarginTemperature
	mock.lockGetMarginTemperature.RUnlock()
	return calls
}

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

// GetMaxClockInfoCalls gets all the calls that were made to GetMaxClockInfo.
// Check the length with:
//
//	len(mockedDevice.GetMaxClockInfoCalls())
func (mock *Device) GetMaxClockInfoCalls() []struct {
	ClockType nvml.ClockType
} {
	var calls []struct {
		ClockType nvml.ClockType
	}
	mock.lockGetMaxClockInfo.RLock()
	calls = mock.calls.GetMaxClockInfo
	mock.lockGetMaxClockInfo.RUnlock()
	return calls
}

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

// GetMaxCustomerBoostClockCalls gets all the calls that were made to GetMaxCustomerBoostClock.
// Check the length with:
//
//	len(mockedDevice.GetMaxCustomerBoostClockCalls())
func (mock *Device) GetMaxCustomerBoostClockCalls() []struct {
	ClockType nvml.ClockType
} {
	var calls []struct {
		ClockType nvml.ClockType
	}
	mock.lockGetMaxCustomerBoostClock.RLock()
	calls = mock.calls.GetMaxCustomerBoostClock
	mock.lockGetMaxCustomerBoostClock.RUnlock()
	return calls
}

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

// GetMaxMigDeviceCountCalls gets all the calls that were made to GetMaxMigDeviceCount.
// Check the length with:
//
//	len(mockedDevice.GetMaxMigDeviceCountCalls())
func (mock *Device) GetMaxMigDeviceCountCalls() []struct {
} {
	var calls []struct {
	}
	mock.lockGetMaxMigDeviceCount.RLock()
	calls = mock.calls.GetMaxMigDeviceCount
	mock.lockGetMaxMigDeviceCount.RUnlock()
	return calls
}

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

// GetMaxPcieLinkGenerationCalls gets all the calls that were made to GetMaxPcieLinkGeneration.
// Check the length with:
//
//	len(mockedDevice.GetMaxPcieLinkGenerationCalls())
func (mock *Device) GetMaxPcieLinkGenerationCalls() []struct {
} {
	var calls []struct {
	}
	mock.lockGetMaxPcieLinkGeneration.RLock()
	calls = mock.calls.GetMaxPcieLinkGeneration
	mock.lockGetMaxPcieLinkGeneration.RUnlock()
	return calls
}

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

// GetMaxPcieLinkWidthCalls gets all the calls that were made to GetMaxPcieLinkWidth.
// Check the length with:
//
//	len(mockedDevice.GetMaxPcieLinkWidthCalls())
func (mock *Device) GetMaxPcieLinkWidthCalls() []struct {
} {
	var calls []struct {
	}
	mock.lockGetMaxPcieLinkWidth.RLock()
	calls = mock.calls.GetMaxPcieLinkWidth
	mock.lockGetMaxPcieLinkWidth.RUnlock()
	return calls
}

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

// GetMemClkMinMaxVfOffsetCalls gets all the calls that were made to GetMemClkMinMaxVfOffset.
// Check the length with:
//
//	len(mockedDevice.GetMemClkMinMaxVfOffsetCalls())
func (mock *Device) GetMemClkMinMaxVfOffsetCalls() []struct {
} {
	var calls []struct {
	}
	mock.lockGetMemClkMinMaxVfOffset.RLock()
	calls = mock.calls.GetMemClkMinMaxVfOffset
	mock.lockGetMemClkMinMaxVfOffset.RUnlock()
	return calls
}

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

// GetMemClkVfOffsetCalls gets all the calls that were made to GetMemClkVfOffset.
// Check the length with:
//
//	len(mockedDevice.GetMemClkVfOffsetCalls())
func (mock *Device) GetMemClkVfOffsetCalls() []struct {
} {
	var calls []struct {
	}
	mock.lockGetMemClkVfOffset.RLock()
	calls = mock.calls.GetMemClkVfOffset
	mock.lockGetMemClkVfOffset.RUnlock()
	return calls
}

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

// GetMemoryAffinityCalls gets all the calls that were made to GetMemoryAffinity.
// Check the length with:
//
//	len(mockedDevice.GetMemoryAffinityCalls())
func (mock *Device) GetMemoryAffinityCalls() []struct {
	N             int
	AffinityScope nvml.AffinityScope
} {
	var calls []struct {
		N             int
		AffinityScope nvml.AffinityScope
	}
	mock.lockGetMemoryAffinity.RLock()
	calls = mock.calls.GetMemoryAffinity
	mock.lockGetMemoryAffinity.RUnlock()
	return calls
}

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

// GetMemoryBusWidthCalls gets all the calls that were made to GetMemoryBusWidth.
// Check the length with:
//
//	len(mockedDevice.GetMemoryBusWidthCalls())
func (mock *Device) GetMemoryBusWidthCalls() []struct {
} {
	var calls []struct {
	}
	mock.lockGetMemoryBusWidth.RLock()
	calls = mock.calls.GetMemoryBusWidth
	mock.lockGetMemoryBusWidth.RUnlock()
	return calls
}

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

// GetMemoryErrorCounterCalls gets all the calls that were made to GetMemoryErrorCounter.
// Check the length with:
//
//	len(mockedDevice.GetMemoryErrorCounterCalls())
func (mock *Device) GetMemoryErrorCounterCalls() []struct {
	MemoryErrorType nvml.MemoryErrorType
	EccCounterType  nvml.EccCounterType
	MemoryLocation  nvml.MemoryLocation
} {
	var calls []struct {
		MemoryErrorType nvml.MemoryErrorType
		EccCounterType  nvml.EccCounterType
		MemoryLocation  nvml.MemoryLocation
	}
	mock.lockGetMemoryErrorCounter.RLock()
	calls = mock.calls.GetMemoryErrorCounter
	mock.lockGetMemoryErrorCounter.RUnlock()
	return calls
}

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

// GetMemoryInfoCalls gets all the calls that were made to GetMemoryInfo.
// Check the length with:
//
//	len(mockedDevice.GetMemoryInfoCalls())
func (mock *Device) GetMemoryInfoCalls() []struct {
} {
	var calls []struct {
	}
	mock.lockGetMemoryInfo.RLock()
	calls = mock.calls.GetMemoryInfo
	mock.lockGetMemoryInfo.RUnlock()
	return calls
}

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

// GetMemoryInfo_v2Calls gets all the calls that were made to GetMemoryInfo_v2.
// Check the length with:
//
//	len(mockedDevice.GetMemoryInfo_v2Calls())
func (mock *Device) GetMemoryInfo_v2Calls() []struct {
} {
	var calls []struct {
	}
	mock.lockGetMemoryInfo_v2.RLock()
	calls = mock.calls.GetMemoryInfo_v2
	mock.lockGetMemoryInfo_v2.RUnlock()
	return calls
}

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

// GetMigDeviceHandleByIndexCalls gets all the calls that were made to GetMigDeviceHandleByIndex.
// Check the length with:
//
//	len(mockedDevice.GetMigDeviceHandleByIndexCalls())
func (mock *Device) GetMigDeviceHandleByIndexCalls() []struct {
	N int
} {
	var calls []struct {
		N int
	}
	mock.lockGetMigDeviceHandleByIndex.RLock()
	calls = mock.calls.GetMigDeviceHandleByIndex
	mock.lockGetMigDeviceHandleByIndex.RUnlock()
	return calls
}

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

// GetMigModeCalls gets all the calls that were made to GetMigMode.
// Check the length with:
//
//	len(mockedDevice.GetMigModeCalls())
func (mock *Device) GetMigModeCalls() []struct {
} {
	var calls []struct {
	}
	mock.lockGetMigMode.RLock()
	calls = mock.calls.GetMigMode
	mock.lockGetMigMode.RUnlock()
	return calls
}

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

// GetMinMaxClockOfPStateCalls gets all the calls that were made to GetMinMaxClockOfPState.
// Check the length with:
//
//	len(mockedDevice.GetMinMaxClockOfPStateCalls())
func (mock *Device) GetMinMaxClockOfPStateCalls() []struct {
	ClockType nvml.ClockType
	Pstates   nvml.Pstates
} {
	var calls []struct {
		ClockType nvml.ClockType
		Pstates   nvml.Pstates
	}
	mock.lockGetMinMaxClockOfPState.RLock()
	calls = mock.calls.GetMinMaxClockOfPState
	mock.lockGetMinMaxClockOfPState.RUnlock()
	return calls
}

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

// GetMinMaxFanSpeedCalls gets all the calls that were made to GetMinMaxFanSpeed.
// Check the length with:
//
//	len(mockedDevice.GetMinMaxFanSpeedCalls())
func (mock *Device) GetMinMaxFanSpeedCalls() []struct {
} {
	var calls []struct {
	}
	mock.lockGetMinMaxFanSpeed.RLock()
	calls = mock.calls.GetMinMaxFanSpeed
	mock.lockGetMinMaxFanSpeed.RUnlock()
	return calls
}

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

// GetMinorNumberCalls gets all the calls that were made to GetMinorNumber.
// Check the length with:
//
//	len(mockedDevice.GetMinorNumberCalls())
func (mock *Device) GetMinorNumberCalls() []struct {
} {
	var calls []struct {
	}
	mock.lockGetMinorNumber.RLock()
	calls = mock.calls.GetMinorNumber
	mock.lockGetMinorNumber.RUnlock()
	return calls
}

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

// GetModuleIdCalls gets all the calls that were made to GetModuleId.
// Check the length with:
//
//	len(mockedDevice.GetModuleIdCalls())
func (mock *Device) GetModuleIdCalls() []struct {
} {
	var calls []struct {
	}
	mock.lockGetModuleId.RLock()
	calls = mock.calls.GetModuleId
	mock.lockGetModuleId.RUnlock()
	return calls
}

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

// GetMultiGpuBoardCalls gets all the calls that were made to GetMultiGpuBoard.
// Check the length with:
//
//	len(mockedDevice.GetMultiGpuBoardCalls())
func (mock *Device) GetMultiGpuBoardCalls() []struct {
} {
	var calls []struct {
	}
	mock.lockGetMultiGpuBoard.RLock()
	calls = mock.calls.GetMultiGpuBoard
	mock.lockGetMultiGpuBoard.RUnlock()
	return calls
}

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

// GetNameCalls gets all the calls that were made to GetName.
// Check the length with:
//
//	len(mockedDevice.GetNameCalls())
func (mock *Device) GetNameCalls() []struct {
} {
	var calls []struct {
	}
	mock.lockGetName.RLock()
	calls = mock.calls.GetName
	mock.lockGetName.RUnlock()
	return calls
}

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

// GetNumFansCalls gets all the calls that were made to GetNumFans.
// Check the length with:
//
//	len(mockedDevice.GetNumFansCalls())
func (mock *Device) GetNumFansCalls() []struct {
} {
	var calls []struct {
	}
	mock.lockGetNumFans.RLock()
	calls = mock.calls.GetNumFans
	mock.lockGetNumFans.RUnlock()
	return calls
}

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

// GetNumGpuCoresCalls gets all the calls that were made to GetNumGpuCores.
// Check the length with:
//
//	len(mockedDevice.GetNumGpuCoresCalls())
func (mock *Device) GetNumGpuCoresCalls() []struct {
} {
	var calls []struct {
	}
	mock.lockGetNumGpuCores.RLock()
	calls = mock.calls.GetNumGpuCores
	mock.lockGetNumGpuCores.RUnlock()
	return calls
}

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

// GetNumaNodeIdCalls gets all the calls that were made to GetNumaNodeId.
// Check the length with:
//
//	len(mockedDevice.GetNumaNodeIdCalls())
func (mock *Device) GetNumaNodeIdCalls() []struct {
} {
	var calls []struct {
	}
	mock.lockGetNumaNodeId.RLock()
	calls = mock.calls.GetNumaNodeId
	mock.lockGetNumaNodeId.RUnlock()
	return calls
}

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

// GetNvLinkCapabilityCalls gets all the calls that were made to GetNvLinkCapability.
// Check the length with:
//
//	len(mockedDevice.GetNvLinkCapabilityCalls())
func (mock *Device) GetNvLinkCapabilityCalls() []struct {
	N                int
	NvLinkCapability nvml.NvLinkCapability
} {
	var calls []struct {
		N                int
		NvLinkCapability nvml.NvLinkCapability
	}
	mock.lockGetNvLinkCapability.RLock()
	calls = mock.calls.GetNvLinkCapability
	mock.lockGetNvLinkCapability.RUnlock()
	return calls
}

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

// GetNvLinkErrorCounterCalls gets all the calls that were made to GetNvLinkErrorCounter.
// Check the length with:
//
//	len(mockedDevice.GetNvLinkErrorCounterCalls())
func (mock *Device) GetNvLinkErrorCounterCalls() []struct {
	N                  int
	NvLinkErrorCounter nvml.NvLinkErrorCounter
} {
	var calls []struct {
		N                  int
		NvLinkErrorCounter nvml.NvLinkErrorCounter
	}
	mock.lockGetNvLinkErrorCounter.RLock()
	calls = mock.calls.GetNvLinkErrorCounter
	mock.lockGetNvLinkErrorCounter.RUnlock()
	return calls
}

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

// GetNvLinkInfoCalls gets all the calls that were made to GetNvLinkInfo.
// Check the length with:
//
//	len(mockedDevice.GetNvLinkInfoCalls())
func (mock *Device) GetNvLinkInfoCalls() []struct {
} {
	var calls []struct {
	}
	mock.lockGetNvLinkInfo.RLock()
	calls = mock.calls.GetNvLinkInfo
	mock.lockGetNvLinkInfo.RUnlock()
	return calls
}

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

// GetNvLinkRemoteDeviceTypeCalls gets all the calls that were made to GetNvLinkRemoteDeviceType.
// Check the length with:
//
//	len(mockedDevice.GetNvLinkRemoteDeviceTypeCalls())
func (mock *Device) GetNvLinkRemoteDeviceTypeCalls() []struct {
	N int
} {
	var calls []struct {
		N int
	}
	mock.lockGetNvLinkRemoteDeviceType.RLock()
	calls = mock.calls.GetNvLinkRemoteDeviceType
	mock.lockGetNvLinkRemoteDeviceType.RUnlock()
	return calls
}

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

// GetNvLinkRemotePciInfoCalls gets all the calls that were made to GetNvLinkRemotePciInfo.
// Check the length with:
//
//	len(mockedDevice.GetNvLinkRemotePciInfoCalls())
func (mock *Device) GetNvLinkRemotePciInfoCalls() []struct {
	N int
} {
	var calls []struct {
		N int
	}
	mock.lockGetNvLinkRemotePciInfo.RLock()
	calls = mock.calls.GetNvLinkRemotePciInfo
	mock.lockGetNvLinkRemotePciInfo.RUnlock()
	return calls
}

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

// GetNvLinkStateCalls gets all the calls that were made to GetNvLinkState.
// Check the length with:
//
//	len(mockedDevice.GetNvLinkStateCalls())
func (mock *Device) GetNvLinkStateCalls() []struct {
	N int
} {
	var calls []struct {
		N int
	}
	mock.lockGetNvLinkState.RLock()
	calls = mock.calls.GetNvLinkState
	mock.lockGetNvLinkState.RUnlock()
	return calls
}

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

// GetNvLinkUtilizationControlCalls gets all the calls that were made to GetNvLinkUtilizationControl.
// Check the length with:
//
//	len(mockedDevice.GetNvLinkUtilizationControlCalls())
func (mock *Device) GetNvLinkUtilizationControlCalls() []struct {
	N1 int
	N2 int
} {
	var calls []struct {
		N1 int
		N2 int
	}
	mock.lockGetNvLinkUtilizationControl.RLock()
	calls = mock.calls.GetNvLinkUtilizationControl
	mock.lockGetNvLinkUtilizationControl.RUnlock()
	return calls
}

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

// GetNvLinkUtilizationCounterCalls gets all the calls that were made to GetNvLinkUtilizationCounter.
// Check the length with:
//
//	len(mockedDevice.GetNvLinkUtilizationCounterCalls())
func (mock *Device) GetNvLinkUtilizationCounterCalls() []struct {
	N1 int
	N2 int
} {
	var calls []struct {
		N1 int
		N2 int
	}
	mock.lockGetNvLinkUtilizationCounter.RLock()
	calls = mock.calls.GetNvLinkUtilizationCounter
	mock.lockGetNvLinkUtilizationCounter.RUnlock()
	return calls
}

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

// GetNvLinkVersionCalls gets all the calls that were made to GetNvLinkVersion.
// Check the length with:
//
//	len(mockedDevice.GetNvLinkVersionCalls())
func (mock *Device) GetNvLinkVersionCalls() []struct {
	N int
} {
	var calls []struct {
		N int
	}
	mock.lockGetNvLinkVersion.RLock()
	calls = mock.calls.GetNvLinkVersion
	mock.lockGetNvLinkVersion.RUnlock()
	return calls
}

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

// GetNvlinkBwModeCalls gets all the calls that were made to GetNvlinkBwMode.
// Check the length with:
//
//	len(mockedDevice.GetNvlinkBwModeCalls())
func (mock *Device) GetNvlinkBwModeCalls() []struct {
} {
	var calls []struct {
	}
	mock.lockGetNvlinkBwMode.RLock()
	calls = mock.calls.GetNvlinkBwMode
	mock.lockGetNvlinkBwMode.RUnlock()
	return calls
}

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

// GetNvlinkSupportedBwModesCalls gets all the calls that were made to GetNvlinkSupportedBwModes.
// Check the length with:
//
//	len(mockedDevice.GetNvlinkSupportedBwModesCalls())
func (mock *Device) GetNvlinkSupportedBwModesCalls() []struct {
} {
	var calls []struct {
	}
	mock.lockGetNvlinkSupportedBwModes.RLock()
	calls = mock.calls.GetNvlinkSupportedBwModes
	mock.lockGetNvlinkSupportedBwModes.RUnlock()
	return calls
}

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

// GetOfaUtilizationCalls gets all the calls that were made to GetOfaUtilization.
// Check the length with:
//
//	len(mockedDevice.GetOfaUtilizationCalls())
func (mock *Device) GetOfaUtilizationCalls() []struct {
} {
	var calls []struct {
	}
	mock.lockGetOfaUtilization.RLock()
	calls = mock.calls.GetOfaUtilization
	mock.lockGetOfaUtilization.RUnlock()
	return calls
}

// GetP2PStatus calls GetP2PStatusFunc.
func (mock *Device) GetP2PStatus(device nvml.Device, gpuP2PCapsIndex nvml.GpuP2PCapsIndex) (nvml.GpuP2PStatus, nvml.Return) {
	if mock.GetP2PStatusFunc == nil {
		panic("Device.GetP2PStatusFunc: method is nil but Device.GetP2PStatus was just called")
	}
	callInfo := struct {
		Device          nvml.Device
		GpuP2PCapsIndex nvml.GpuP2PCapsIndex
	}{
		Device:          device,
		GpuP2PCapsIndex: gpuP2PCapsIndex,
	}
	mock.lockGetP2PStatus.Lock()
	mock.calls.GetP2PStatus = append(mock.calls.GetP2PStatus, callInfo)
	mock.lockGetP2PStatus.Unlock()
	return mock.GetP2PStatusFunc(device, gpuP2PCapsIndex)
}

// GetP2PStatusCalls gets all the calls that were made to GetP2PStatus.
// Check the length with:
//
//	len(mockedDevice.GetP2PStatusCalls())
func (mock *Device) GetP2PStatusCalls() []struct {
	Device          nvml.Device
	GpuP2PCapsIndex nvml.GpuP2PCapsIndex
} {
	var calls []struct {
		Device          nvml.Device
		GpuP2PCapsIndex nvml.GpuP2PCapsIndex
	}
	mock.lockGetP2PStatus.RLock()
	calls = mock.calls.GetP2PStatus
	mock.lockGetP2PStatus.RUnlock()
	return calls
}

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

// GetPciInfoCalls gets all the calls that were made to GetPciInfo.
// Check the length with:
//
//	len(mockedDevice.GetPciInfoCalls())
func (mock *Device) GetPciInfoCalls() []struct {
} {
	var calls []struct {
	}
	mock.lockGetPciInfo.RLock()
	calls = mock.calls.GetPciInfo
	mock.lockGetPciInfo.RUnlock()
	return calls
}

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

// GetPciInfoExtCalls gets all the calls that were made to GetPciInfoExt.
// Check the length with:
//
//	len(mockedDevice.GetPciInfoExtCalls())
func (mock *Device) GetPciInfoExtCalls() []struct {
} {
	var calls []struct {
	}
	mock.lockGetPciInfoExt.RLock()
	calls = mock.calls.GetPciInfoExt
	mock.lockGetPciInfoExt.RUnlock()
	return calls
}

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

// GetPcieLinkMaxSpeedCalls gets all the calls that were made to GetPcieLinkMaxSpeed.
// Check the length with:
//
//	len(mockedDevice.GetPcieLinkMaxSpeedCalls())
func (mock *Device) GetPcieLinkMaxSpeedCalls() []struct {
} {
	var calls []struct {
	}
	mock.lockGetPcieLinkMaxSpeed.RLock()
	calls = mock.calls.GetPcieLinkMaxSpeed
	mock.lockGetPcieLinkMaxSpeed.RUnlock()
	return calls
}

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

// GetPcieReplayCounterCalls gets all the calls that were made to GetPcieReplayCounter.
// Check the length with:
//
//	len(mockedDevice.GetPcieReplayCounterCalls())
func (mock *Device) GetPcieReplayCounterCalls() []struct {
} {
	var calls []struct {
	}
	mock.lockGetPcieReplayCounter.RLock()
	calls = mock.calls.GetPcieReplayCounter
	mock.lockGetPcieReplayCounter.RUnlock()
	return calls
}

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

// GetPcieSpeedCalls gets all the calls that were made to GetPcieSpeed.
// Check the length with:
//
//	len(mockedDevice.GetPcieSpeedCalls())
func (mock *Device) GetPcieSpeedCalls() []struct {
} {
	var calls []struct {
	}
	mock.lockGetPcieSpeed.RLock()
	calls = mock.calls.GetPcieSpeed
	mock.lockGetPcieSpeed.RUnlock()
	return calls
}

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

// GetPcieThroughputCalls gets all the calls that were made to GetPcieThroughput.
// Check the length with:
//
//	len(mockedDevice.GetPcieThroughputCalls())
func (mock *Device) GetPcieThroughputCalls() []struct {
	PcieUtilCounter nvml.PcieUtilCounter
} {
	var calls []struct {
		PcieUtilCounter nvml.PcieUtilCounter
	}
	mock.lockGetPcieThroughput.RLock()
	calls = mock.calls.GetPcieThroughput
	mock.lockGetPcieThroughput.RUnlock()
	return calls
}

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

// GetPdiCalls gets all the calls that were made to GetPdi.
// Check the length with:
//
//	len(mockedDevice.GetPdiCalls())
func (mock *Device) GetPdiCalls() []struct {
} {
	var calls []struct {
	}
	mock.lockGetPdi.RLock()
	calls = mock.calls.GetPdi
	mock.lockGetPdi.RUnlock()
	return calls
}

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

// GetPerformanceModesCalls gets all the calls that were made to GetPerformanceModes.
// Check the length with:
//
//	len(mockedDevice.GetPerformanceModesCalls())
func (mock *Device) GetPerformanceModesCalls() []struct {
} {
	var calls []struct {
	}
	mock.lockGetPerformanceModes.RLock()
	calls = mock.calls.GetPerformanceModes
	mock.lockGetPerformanceModes.RUnlock()
	return calls
}

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

// GetPerformanceStateCalls gets all the calls that were made to GetPerformanceState.
// Check the length with:
//
//	len(mockedDevice.GetPerformanceStateCalls())
func (mock *Device) GetPerformanceStateCalls() []struct {
} {
	var calls []struct {
	}
	mock.lockGetPerformanceState.RLock()
	calls = mock.calls.GetPerformanceState
	mock.lockGetPerformanceState.RUnlock()
	return calls
}

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

// GetPersistenceModeCalls gets all the calls that were made to GetPersistenceMode.
// Check the length with:
//
//	len(mockedDevice.GetPersistenceModeCalls())
func (mock *Device) GetPersistenceModeCalls() []struct {
} {
	var calls []struct {
	}
	mock.lockGetPersistenceMode.RLock()
	calls = mock.calls.GetPersistenceMode
	mock.lockGetPersistenceMode.RUnlock()
	return calls
}

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

// GetPgpuMetadataStringCalls gets all the calls that were made to GetPgpuMetadataString.
// Check the length with:
//
//	len(mockedDevice.GetPgpuMetadataStringCalls())
func (mock *Device) GetPgpuMetadataStringCalls() []struct {
} {
	var calls []struct {
	}
	mock.lockGetPgpuMetadataString.RLock()
	calls = mock.calls.GetPgpuMetadataString
	mock.lockGetPgpuMetadataString.RUnlock()
	return calls
}

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

// GetPlatformInfoCalls gets all the calls that were made to GetPlatformInfo.
// Check the length with:
//
//	len(mockedDevice.GetPlatformInfoCalls())
func (mock *Device) GetPlatformInfoCalls() []struct {
} {
	var calls []struct {
	}
	mock.lockGetPlatformInfo.RLock()
	calls = mock.calls.GetPlatformInfo
	mock.lockGetPlatformInfo.RUnlock()
	return calls
}

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

// GetPowerManagementDefaultLimitCalls gets all the calls that were made to GetPowerManagementDefaultLimit.
// Check the length with:
//
//	len(mockedDevice.GetPowerManagementDefaultLimitCalls())
func (mock *Device) GetPowerManagementDefaultLimitCalls() []struct {
} {
	var calls []struct {
	}
	mock.lockGetPowerManagementDefaultLimit.RLock()
	calls = mock.calls.GetPowerManagementDefaultLimit
	mock.lockGetPowerManagementDefaultLimit.RUnlock()
	return calls
}

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

// GetPowerManagementLimitCalls gets all the calls that were made to GetPowerManagementLimit.
// Check the length with:
//
//	len(mockedDevice.GetPowerManagementLimitCalls())
func (mock *Device) GetPowerManagementLimitCalls() []struct {
} {
	var calls []struct {
	}
	mock.lockGetPowerManagementLimit.RLock()
	calls = mock.calls.GetPowerManagementLimit
	mock.lockGetPowerManagementLimit.RUnlock()
	return calls
}

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

// GetPowerManagementLimitConstraintsCalls gets all the calls that were made to GetPowerManagementLimitConstraints.
// Check the length with:
//
//	len(mockedDevice.GetPowerManagementLimitConstraintsCalls())
func (mock *Device) GetPowerManagementLimitConstraintsCalls() []struct {
} {
	var calls []struct {
	}
	mock.lockGetPowerManagementLimitConstraints.RLock()
	calls = mock.calls.GetPowerManagementLimitConstraints
	mock.lockGetPowerManagementLimitConstraints.RUnlock()
	return calls
}

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

// GetPowerManagementModeCalls gets all the calls that were made to GetPowerManagementMode.
// Check the length with:
//
//	len(mockedDevice.GetPowerManagementModeCalls())
func (mock *Device) GetPowerManagementModeCalls() []struct {
} {
	var calls []struct {
	}
	mock.lockGetPowerManagementMode.RLock()
	calls = mock.calls.GetPowerManagementMode
	mock.lockGetPowerManagementMode.RUnlock()
	return calls
}

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

// GetPowerMizerMode_v1Calls gets all the calls that were made to GetPowerMizerMode_v1.
// Check the length with:
//
//	len(mockedDevice.GetPowerMizerMode_v1Calls())
func (mock *Device) GetPowerMizerMode_v1Calls() []struct {
} {
	var calls []struct {
	}
	mock.lockGetPowerMizerMode_v1.RLock()
	calls = mock.calls.GetPowerMizerMode_v1
	mock.lockGetPowerMizerMode_v1.RUnlock()
	return calls
}

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

// GetPowerSourceCalls gets all the calls that were made to GetPowerSource.
// Check the length with:
//
//	len(mockedDevice.GetPowerSourceCalls())
func (mock *Device) GetPowerSourceCalls() []struct {
} {
	var calls []struct {
	}
	mock.lockGetPowerSource.RLock()
	calls = mock.calls.GetPowerSource
	mock.lockGetPowerSource.RUnlock()
	return calls
}

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

// GetPowerStateCalls gets all the calls that were made to GetPowerState.
// Check the length with:
//
//	len(mockedDevice.GetPowerStateCalls())
func (mock *Device) GetPowerStateCalls() []struct {
} {
	var calls []struct {
	}
	mock.lockGetPowerState.RLock()
	calls = mock.calls.GetPowerState
	mock.lockGetPowerState.RUnlock()
	return calls
}

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

// GetPowerUsageCalls gets all the calls that were made to GetPowerUsage.
// Check the length with:
//
//	len(mockedDevice.GetPowerUsageCalls())
func (mock *Device) GetPowerUsageCalls() []struct {
} {
	var calls []struct {
	}
	mock.lockGetPowerUsage.RLock()
	calls = mock.calls.GetPowerUsage
	mock.lockGetPowerUsage.RUnlock()
	return calls
}

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

// GetProcessUtilizationCalls gets all the calls that were made to GetProcessUtilization.
// Check the length with:
//
//	len(mockedDevice.GetProcessUtilizationCalls())
func (mock *Device) GetProcessUtilizationCalls() []struct {
	V uint64
} {
	var calls []struct {
		V uint64
	}
	mock.lockGetProcessUtilization.RLock()
	calls = mock.calls.GetProcessUtilization
	mock.lockGetProcessUtilization.RUnlock()
	return calls
}

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

// GetProcessesUtilizationInfoCalls gets all the calls that were made to GetProcessesUtilizationInfo.
// Check the length with:
//
//	len(mockedDevice.GetProcessesUtilizationInfoCalls())
func (mock *Device) GetProcessesUtilizationInfoCalls() []struct {
} {
	var calls []struct {
	}
	mock.lockGetProcessesUtilizationInfo.RLock()
	calls = mock.calls.GetProcessesUtilizationInfo
	mock.lockGetProcessesUtilizationInfo.RUnlock()
	return calls
}

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

// GetRemappedRowsCalls gets all the calls that were made to GetRemappedRows.
// Check the length with:
//
//	len(mockedDevice.GetRemappedRowsCalls())
func (mock *Device) GetRemappedRowsCalls() []struct {
} {
	var calls []struct {
	}
	mock.lockGetRemappedRows.RLock()
	calls = mock.calls.GetRemappedRows
	mock.lockGetRemappedRows.RUnlock()
	return calls
}

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

// GetRepairStatusCalls gets all the calls that were made to GetRepairStatus.
// Check the length with:
//
//	len(mockedDevice.GetRepairStatusCalls())
func (mock *Device) GetRepairStatusCalls() []struct {
} {
	var calls []struct {
	}
	mock.lockGetRepairStatus.RLock()
	calls = mock.calls.GetRepairStatus
	mock.lockGetRepairStatus.RUnlock()
	return calls
}

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

// GetRetiredPagesCalls gets all the calls that were made to GetRetiredPages.
// Check the length with:
//
//	len(mockedDevice.GetRetiredPagesCalls())
func (mock *Device) GetRetiredPagesCalls() []struct {
	PageRetirementCause nvml.PageRetirementCause
} {
	var calls []struct {
		PageRetirementCause nvml.PageRetirementCause
	}
	mock.lockGetRetiredPages.RLock()
	calls = mock.calls.GetRetiredPages
	mock.lockGetRetiredPages.RUnlock()
	return calls
}

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

// GetRetiredPagesPendingStatusCalls gets all the calls that were made to GetRetiredPagesPendingStatus.
// Check the length with:
//
//	len(mockedDevice.GetRetiredPagesPendingStatusCalls())
func (mock *Device) GetRetiredPagesPendingStatusCalls() []struct {
} {
	var calls []struct {
	}
	mock.lockGetRetiredPagesPendingStatus.RLock()
	calls = mock.calls.GetRetiredPagesPendingStatus
	mock.lockGetRetiredPagesPendingStatus.RUnlock()
	return calls
}

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

// GetRetiredPages_v2Calls gets all the calls that were made to GetRetiredPages_v2.
// Check the length with:
//
//	len(mockedDevice.GetRetiredPages_v2Calls())
func (mock *Device) GetRetiredPages_v2Calls() []struct {
	PageRetirementCause nvml.PageRetirementCause
} {
	var calls []struct {
		PageRetirementCause nvml.PageRetirementCause
	}
	mock.lockGetRetiredPages_v2.RLock()
	calls = mock.calls.GetRetiredPages_v2
	mock.lockGetRetiredPages_v2.RUnlock()
	return calls
}

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

// GetRowRemapperHistogramCalls gets all the calls that were made to GetRowRemapperHistogram.
// Check the length with:
//
//	len(mockedDevice.GetRowRemapperHistogramCalls())
func (mock *Device) GetRowRemapperHistogramCalls() []struct {
} {
	var calls []struct {
	}
	mock.lockGetRowRemapperHistogram.RLock()
	calls = mock.calls.GetRowRemapperHistogram
	mock.lockGetRowRemapperHistogram.RUnlock()
	return calls
}

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

// GetRunningProcessDetailListCalls gets all the calls that were made to GetRunningProcessDetailList.
// Check the length with:
//
//	len(mockedDevice.GetRunningProcessDetailListCalls())
func (mock *Device) GetRunningProcessDetailListCalls() []struct {
} {
	var calls []struct {
	}
	mock.lockGetRunningProcessDetailList.RLock()
	calls = mock.calls.GetRunningProcessDetailList
	mock.lockGetRunningProcessDetailList.RUnlock()
	return calls
}

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

// GetSamplesCalls gets all the calls that were made to GetSamples.
// Check the length with:
//
//	len(mockedDevice.GetSamplesCalls())
func (mock *Device) GetSamplesCalls() []struct {
	SamplingType nvml.SamplingType
	V            uint64
} {
	var calls []struct {
		SamplingType nvml.SamplingType
		V            uint64
	}
	mock.lockGetSamples.RLock()
	calls = mock.calls.GetSamples
	mock.lockGetSamples.RUnlock()
	return calls
}

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

// GetSerialCalls gets all the calls that were made to GetSerial.
// Check the length with:
//
//	len(mockedDevice.GetSerialCalls())
func (mock *Device) GetSerialCalls() []struct {
} {
	var calls []struct {
	}
	mock.lockGetSerial.RLock()
	calls = mock.calls.GetSerial
	mock.lockGetSerial.RUnlock()
	return calls
}

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

// GetSramEccErrorStatusCalls gets all the calls that were made to GetSramEccErrorStatus.
// Check the length with:
//
//	len(mockedDevice.GetSramEccErrorStatusCalls())
func (mock *Device) GetSramEccErrorStatusCalls() []struct {
} {
	var calls []struct {
	}
	mock.lockGetSramEccErrorStatus.RLock()
	calls = mock.calls.GetSramEccErrorStatus
	mock.lockGetSramEccErrorStatus.RUnlock()
	return calls
}

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

// GetSramUniqueUncorrectedEccErrorCountsCalls gets all the calls that were made to GetSramUniqueUncorrectedEccErrorCounts.
// Check the length with:
//
//	len(mockedDevice.GetSramUniqueUncorrectedEccErrorCountsCalls())
func (mock *Device) GetSramUniqueUncorrectedEccErrorCountsCalls() []struct {
	EccSramUniqueUncorrectedErrorCounts *nvml.EccSramUniqueUncorrectedErrorCounts
} {
	var calls []struct {
		EccSramUniqueUncorrectedErrorCounts *nvml.EccSramUniqueUncorrectedErrorCounts
	}
	mock.lockGetSramUniqueUncorrectedEccErrorCounts.RLock()
	calls = mock.calls.GetSramUniqueUncorrectedEccErrorCounts
	mock.lockGetSramUniqueUncorrectedEccErrorCounts.RUnlock()
	return calls
}

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

// GetSupportedClocksEventReasonsCalls gets all the calls that were made to GetSupportedClocksEventReasons.
// Check the length with:
//
//	len(mockedDevice.GetSupportedClocksEventReasonsCalls())
func (mock *Device) GetSupportedClocksEventReasonsCalls() []struct {
} {
	var calls []struct {
	}
	mock.lockGetSupportedClocksEventReasons.RLock()
	calls = mock.calls.GetSupportedClocksEventReasons
	mock.lockGetSupportedClocksEventReasons.RUnlock()
	return calls
}

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

// GetSupportedClocksThrottleReasonsCalls gets all the calls that were made to GetSupportedClocksThrottleReasons.
// Check the length with:
//
//	len(mockedDevice.GetSupportedClocksThrottleReasonsCalls())
func (mock *Device) GetSupportedClocksThrottleReasonsCalls() []struct {
} {
	var calls []struct {
	}
	mock.lockGetSupportedClocksThrottleReasons.RLock()
	calls = mock.calls.GetSupportedClocksThrottleReasons
	mock.lockGetSupportedClocksThrottleReasons.RUnlock()
	return calls
}

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

// GetSupportedEventTypesCalls gets all the calls that were made to GetSupportedEventTypes.
// Check the length with:
//
//	len(mockedDevice.GetSupportedEventTypesCalls())
func (mock *Device) GetSupportedEventTypesCalls() []struct {
} {
	var calls []struct {
	}
	mock.lockGetSupportedEventTypes.RLock()
	calls = mock.calls.GetSupportedEventTypes
	mock.lockGetSupportedEventTypes.RUnlock()
	return calls
}

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

// GetSupportedGraphicsClocksCalls gets all the calls that were made to GetSupportedGraphicsClocks.
// Check the length with:
//
//	len(mockedDevice.GetSupportedGraphicsClocksCalls())
func (mock *Device) GetSupportedGraphicsClocksCalls() []struct {
	N int
} {
	var calls []struct {
		N int
	}
	mock.lockGetSupportedGraphicsClocks.RLock()
	calls = mock.calls.GetSupportedGraphicsClocks
	mock.lockGetSupportedGraphicsClocks.RUnlock()
	return calls
}

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

// GetSupportedMemoryClocksCalls gets all the calls that were made to GetSupportedMemoryClocks.
// Check the length with:
//
//	len(mockedDevice.GetSupportedMemoryClocksCalls())
func (mock *Device) GetSupportedMemoryClocksCalls() []struct {
} {
	var calls []struct {
	}
	mock.lockGetSupportedMemoryClocks.RLock()
	calls = mock.calls.GetSupportedMemoryClocks
	mock.lockGetSupportedMemoryClocks.RUnlock()
	return calls
}

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

// GetSupportedPerformanceStatesCalls gets all the calls that were made to GetSupportedPerformanceStates.
// Check the length with:
//
//	len(mockedDevice.GetSupportedPerformanceStatesCalls())
func (mock *Device) GetSupportedPerformanceStatesCalls() []struct {
} {
	var calls []struct {
	}
	mock.lockGetSupportedPerformanceStates.RLock()
	calls = mock.calls.GetSupportedPerformanceStates
	mock.lockGetSupportedPerformanceStates.RUnlock()
	return calls
}

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

// GetSupportedVgpusCalls gets all the calls that were made to GetSupportedVgpus.
// Check the length with:
//
//	len(mockedDevice.GetSupportedVgpusCalls())
func (mock *Device) GetSupportedVgpusCalls() []struct {
} {
	var calls []struct {
	}
	mock.lockGetSupportedVgpus.RLock()
	calls = mock.calls.GetSupportedVgpus
	mock.lockGetSupportedVgpus.RUnlock()
	return calls
}

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

// GetTargetFanSpeedCalls gets all the calls that were made to GetTargetFanSpeed.
// Check the length with:
//
//	len(mockedDevice.GetTargetFanSpeedCalls())
func (mock *Device) GetTargetFanSpeedCalls() []struct {
	N int
} {
	var calls []struct {
		N int
	}
	mock.lockGetTargetFanSpeed.RLock()
	calls = mock.calls.GetTargetFanSpeed
	mock.lockGetTargetFanSpeed.RUnlock()
	return calls
}

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

// GetTemperatureCalls gets all the calls that were made to GetTemperature.
// Check the length with:
//
//	len(mockedDevice.GetTemperatureCalls())
func (mock *Device) GetTemperatureCalls() []struct {
	TemperatureSensors nvml.TemperatureSensors
} {
	var calls []struct {
		TemperatureSensors nvml.TemperatureSensors
	}
	mock.lockGetTemperature.RLock()
	calls = mock.calls.GetTemperature
	mock.lockGetTemperature.RUnlock()
	return calls
}

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

// GetTemperatureThresholdCalls gets all the calls that were made to GetTemperatureThreshold.
// Check the length with:
//
//	len(mockedDevice.GetTemperatureThresholdCalls())
func (mock *Device) GetTemperatureThresholdCalls() []struct {
	TemperatureThresholds nvml.TemperatureThresholds
} {
	var calls []struct {
		TemperatureThresholds nvml.TemperatureThresholds
	}
	mock.lockGetTemperatureThreshold.RLock()
	calls = mock.calls.GetTemperatureThreshold
	mock.lockGetTemperatureThreshold.RUnlock()
	return calls
}

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

// GetTemperatureVCalls gets all the calls that were made to GetTemperatureV.
// Check the length with:
//
//	len(mockedDevice.GetTemperatureVCalls())
func (mock *Device) GetTemperatureVCalls() []struct {
} {
	var calls []struct {
	}
	mock.lockGetTemperatureV.RLock()
	calls = mock.calls.GetTemperatureV
	mock.lockGetTemperatureV.RUnlock()
	return calls
}

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

// GetThermalSettingsCalls gets all the calls that were made to GetThermalSettings.
// Check the length with:
//
//	len(mockedDevice.GetThermalSettingsCalls())
func (mock *Device) GetThermalSettingsCalls() []struct {
	V uint32
} {
	var calls []struct {
		V uint32
	}
	mock.lockGetThermalSettings.RLock()
	calls = mock.calls.GetThermalSettings
	mock.lockGetThermalSettings.RUnlock()
	return calls
}

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

// GetTopologyCommonAncestorCalls gets all the calls that were made to GetTopologyCommonAncestor.
// Check the length with:
//
//	len(mockedDevice.GetTopologyCommonAncestorCalls())
func (mock *Device) GetTopologyCommonAncestorCalls() []struct {
	Device nvml.Device
} {
	var calls []struct {
		Device nvml.Device
	}
	mock.lockGetTopologyCommonAncestor.RLock()
	calls = mock.calls.GetTopologyCommonAncestor
	mock.lockGetTopologyCommonAncestor.RUnlock()
	return calls
}

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

// GetTopologyNearestGpusCalls gets all the calls that were made to GetTopologyNearestGpus.
// Check the length with:
//
//	len(mockedDevice.GetTopologyNearestGpusCalls())
func (mock *Device) GetTopologyNearestGpusCalls() []struct {
	GpuTopologyLevel nvml.GpuTopologyLevel
} {
	var calls []struct {
		GpuTopologyLevel nvml.GpuTopologyLevel
	}
	mock.lockGetTopologyNearestGpus.RLock()
	calls = mock.calls.GetTopologyNearestGpus
	mock.lockGetTopologyNearestGpus.RUnlock()
	return calls
}

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

// GetTotalEccErrorsCalls gets all the calls that were made to GetTotalEccErrors.
// Check the length with:
//
//	len(mockedDevice.GetTotalEccErrorsCalls())
func (mock *Device) GetTotalEccErrorsCalls() []struct {
	MemoryErrorType nvml.MemoryErrorType
	EccCounterType  nvml.EccCounterType
} {
	var calls []struct {
		MemoryErrorType nvml.MemoryErrorType
		EccCounterType  nvml.EccCounterType
	}
	mock.lockGetTotalEccErrors.RLock()
	calls = mock.calls.GetTotalEccErrors
	mock.lockGetTotalEccErrors.RUnlock()
	return calls
}

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

// GetTotalEnergyConsumptionCalls gets all the calls that were made to GetTotalEnergyConsumption.
// Check the length with:
//
//	len(mockedDevice.GetTotalEnergyConsumptionCalls())
func (mock *Device) GetTotalEnergyConsumptionCalls() []struct {
} {
	var calls []struct {
	}
	mock.lockGetTotalEnergyConsumption.RLock()
	calls = mock.calls.GetTotalEnergyConsumption
	mock.lockGetTotalEnergyConsumption.RUnlock()
	return calls
}

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

// GetUUIDCalls gets all the calls that were made to GetUUID.
// Check the length with:
//
//	len(mockedDevice.GetUUIDCalls())
func (mock *Device) GetUUIDCalls() []struct {
} {
	var calls []struct {
	}
	mock.lockGetUUID.RLock()
	calls = mock.calls.GetUUID
	mock.lockGetUUID.RUnlock()
	return calls
}

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

// GetUtilizationRatesCalls gets all the calls that were made to GetUtilizationRates.
// Check the length with:
//
//	len(mockedDevice.GetUtilizationRatesCalls())
func (mock *Device) GetUtilizationRatesCalls() []struct {
} {
	var calls []struct {
	}
	mock.lockGetUtilizationRates.RLock()
	calls = mock.calls.GetUtilizationRates
	mock.lockGetUtilizationRates.RUnlock()
	return calls
}

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

// GetVbiosVersionCalls gets all the calls that were made to GetVbiosVersion.
// Check the length with:
//
//	len(mockedDevice.GetVbiosVersionCalls())
func (mock *Device) GetVbiosVersionCalls() []struct {
} {
	var calls []struct {
	}
	mock.lockGetVbiosVersion.RLock()
	calls = mock.calls.GetVbiosVersion
	mock.lockGetVbiosVersion.RUnlock()
	return calls
}

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

// GetVgpuCapabilitiesCalls gets all the calls that were made to GetVgpuCapabilities.
// Check the length with:
//
//	len(mockedDevice.GetVgpuCapabilitiesCalls())
func (mock *Device) GetVgpuCapabilitiesCalls() []struct {
	DeviceVgpuCapability nvml.DeviceVgpuCapability
} {
	var calls []struct {
		DeviceVgpuCapability nvml.DeviceVgpuCapability
	}
	mock.lockGetVgpuCapabilities.RLock()
	calls = mock.calls.GetVgpuCapabilities
	mock.lockGetVgpuCapabilities.RUnlock()
	return calls
}

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

// GetVgpuHeterogeneousModeCalls gets all the calls that were made to GetVgpuHeterogeneousMode.
// Check the length with:
//
//	len(mockedDevice.GetVgpuHeterogeneousModeCalls())
func (mock *Device) GetVgpuHeterogeneousModeCalls() []struct {
} {
	var calls []struct {
	}
	mock.lockGetVgpuHeterogeneousMode.RLock()
	calls = mock.calls.GetVgpuHeterogeneousMode
	mock.lockGetVgpuHeterogeneousMode.RUnlock()
	return calls
}

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

// GetVgpuInstancesUtilizationInfoCalls gets all the calls that were made to GetVgpuInstancesUtilizationInfo.
// Check the length with:
//
//	len(mockedDevice.GetVgpuInstancesUtilizationInfoCalls())
func (mock *Device) GetVgpuInstancesUtilizationInfoCalls() []struct {
} {
	var calls []struct {
	}
	mock.lockGetVgpuInstancesUtilizationInfo.RLock()
	calls = mock.calls.GetVgpuInstancesUtilizationInfo
	mock.lockGetVgpuInstancesUtilizationInfo.RUnlock()
	return calls
}

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

// GetVgpuMetadataCalls gets all the calls that were made to GetVgpuMetadata.
// Check the length with:
//
//	len(mockedDevice.GetVgpuMetadataCalls())
func (mock *Device) GetVgpuMetadataCalls() []struct {
} {
	var calls []struct {
	}
	mock.lockGetVgpuMetadata.RLock()
	calls = mock.calls.GetVgpuMetadata
	mock.lockGetVgpuMetadata.RUnlock()
	return calls
}

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

// GetVgpuProcessUtilizationCalls gets all the calls that were made to GetVgpuProcessUtilization.
// Check the length with:
//
//	len(mockedDevice.GetVgpuProcessUtilizationCalls())
func (mock *Device) GetVgpuProcessUtilizationCalls() []struct {
	V uint64
} {
	var calls []struct {
		V uint64
	}
	mock.lockGetVgpuProcessUtilization.RLock()
	calls = mock.calls.GetVgpuProcessUtilization
	mock.lockGetVgpuProcessUtilization.RUnlock()
	return calls
}

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

// GetVgpuProcessesUtilizationInfoCalls gets all the calls that were made to GetVgpuProcessesUtilizationInfo.
// Check the length with:
//
//	len(mockedDevice.GetVgpuProcessesUtilizationInfoCalls())
func (mock *Device) GetVgpuProcessesUtilizationInfoCalls() []struct {
} {
	var calls []struct {
	}
	mock.lockGetVgpuProcessesUtilizationInfo.RLock()
	calls = mock.calls.GetVgpuProcessesUtilizationInfo
	mock.lockGetVgpuProcessesUtilizationInfo.RUnlock()
	return calls
}

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

// GetVgpuSchedulerCapabilitiesCalls gets all the calls that were made to GetVgpuSchedulerCapabilities.
// Check the length with:
//
//	len(mockedDevice.GetVgpuSchedulerCapabilitiesCalls())
func (mock *Device) GetVgpuSchedulerCapabilitiesCalls() []struct {
} {
	var calls []struct {
	}
	mock.lockGetVgpuSchedulerCapabilities.RLock()
	calls = mock.calls.GetVgpuSchedulerCapabilities
	mock.lockGetVgpuSchedulerCapabilities.RUnlock()
	return calls
}

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

// GetVgpuSchedulerLogCalls gets all the calls that were made to GetVgpuSchedulerLog.
// Check the length with:
//
//	len(mockedDevice.GetVgpuSchedulerLogCalls())
func (mock *Device) GetVgpuSchedulerLogCalls() []struct {
} {
	var calls []struct {
	}
	mock.lockGetVgpuSchedulerLog.RLock()
	calls = mock.calls.GetVgpuSchedulerLog
	mock.lockGetVgpuSchedulerLog.RUnlock()
	return calls
}

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

// GetVgpuSchedulerStateCalls gets all the calls that were made to GetVgpuSchedulerState.
// Check the length with:
//
//	len(mockedDevice.GetVgpuSchedulerStateCalls())
func (mock *Device) GetVgpuSchedulerStateCalls() []struct {
} {
	var calls []struct {
	}
	mock.lockGetVgpuSchedulerState.RLock()
	calls = mock.calls.GetVgpuSchedulerState
	mock.lockGetVgpuSchedulerState.RUnlock()
	return calls
}

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

// GetVgpuTypeCreatablePlacementsCalls gets all the calls that were made to GetVgpuTypeCreatablePlacements.
// Check the length with:
//
//	len(mockedDevice.GetVgpuTypeCreatablePlacementsCalls())
func (mock *Device) GetVgpuTypeCreatablePlacementsCalls() []struct {
	VgpuTypeId nvml.VgpuTypeId
} {
	var calls []struct {
		VgpuTypeId nvml.VgpuTypeId
	}
	mock.lockGetVgpuTypeCreatablePlacements.RLock()
	calls = mock.calls.GetVgpuTypeCreatablePlacements
	mock.lockGetVgpuTypeCreatablePlacements.RUnlock()
	return calls
}

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

// GetVgpuTypeSupportedPlacementsCalls gets all the calls that were made to GetVgpuTypeSupportedPlacements.
// Check the length with:
//
//	len(mockedDevice.GetVgpuTypeSupportedPlacementsCalls())
func (mock *Device) GetVgpuTypeSupportedPlacementsCalls() []struct {
	VgpuTypeId nvml.VgpuTypeId
} {
	var calls []struct {
		VgpuTypeId nvml.VgpuTypeId
	}
	mock.lockGetVgpuTypeSupportedPlacements.RLock()
	calls = mock.calls.GetVgpuTypeSupportedPlacements
	mock.lockGetVgpuTypeSupportedPlacements.RUnlock()
	return calls
}

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

// GetVgpuUtilizationCalls gets all the calls that were made to GetVgpuUtilization.
// Check the length with:
//
//	len(mockedDevice.GetVgpuUtilizationCalls())
func (mock *Device) GetVgpuUtilizationCalls() []struct {
	V uint64
} {
	var calls []struct {
		V uint64
	}
	mock.lockGetVgpuUtilization.RLock()
	calls = mock.calls.GetVgpuUtilization
	mock.lockGetVgpuUtilization.RUnlock()
	return calls
}

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

// GetViolationStatusCalls gets all the calls that were made to GetViolationStatus.
// Check the length with:
//
//	len(mockedDevice.GetViolationStatusCalls())
func (mock *Device) GetViolationStatusCalls() []struct {
	PerfPolicyType nvml.PerfPolicyType
} {
	var calls []struct {
		PerfPolicyType nvml.PerfPolicyType
	}
	mock.lockGetViolationStatus.RLock()
	calls = mock.calls.GetViolationStatus
	mock.lockGetViolationStatus.RUnlock()
	return calls
}

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

// GetVirtualizationModeCalls gets all the calls that were made to GetVirtualizationMode.
// Check the length with:
//
//	len(mockedDevice.GetVirtualizationModeCalls())
func (mock *Device) GetVirtualizationModeCalls() []struct {
} {
	var calls []struct {
	}
	mock.lockGetVirtualizationMode.RLock()
	calls = mock.calls.GetVirtualizationMode
	mock.lockGetVirtualizationMode.RUnlock()
	return calls
}

// GpmMigSampleGet calls GpmMigSampleGetFunc.
func (mock *Device) GpmMigSampleGet(n int, gpmSample nvml.GpmSample) nvml.Return {
	if mock.GpmMigSampleGetFunc == nil {
		panic("Device.GpmMigSampleGetFunc: method is nil but Device.GpmMigSampleGet was just called")
	}
	callInfo := struct {
		N         int
		GpmSample nvml.GpmSample
	}{
		N:         n,
		GpmSample: gpmSample,
	}
	mock.lockGpmMigSampleGet.Lock()
	mock.calls.GpmMigSampleGet = append(mock.calls.GpmMigSampleGet, callInfo)
	mock.lockGpmMigSampleGet.Unlock()
	return mock.GpmMigSampleGetFunc(n, gpmSample)
}

// GpmMigSampleGetCalls gets all the calls that were made to GpmMigSampleGet.
// Check the length with:
//
//	len(mockedDevice.GpmMigSampleGetCalls())
func (mock *Device) GpmMigSampleGetCalls() []struct {
	N         int
	GpmSample nvml.GpmSample
} {
	var calls []struct {
		N         int
		GpmSample nvml.GpmSample
	}
	mock.lockGpmMigSampleGet.RLock()
	calls = mock.calls.GpmMigSampleGet
	mock.lockGpmMigSampleGet.RUnlock()
	return calls
}

// GpmQueryDeviceSupport calls GpmQueryDeviceSupportFunc.
func (mock *Device) GpmQueryDeviceSupport() (nvml.GpmSupport, nvml.Return) {
	if mock.GpmQueryDeviceSupportFunc == nil {
		panic("Device.GpmQueryDeviceSupportFunc: method is nil but Device.GpmQueryDeviceSupport was just called")
	}
	callInfo := struct {
	}{}
	mock.lockGpmQueryDeviceSupport.Lock()
	mock.calls.GpmQueryDeviceSupport = append(mock.calls.GpmQueryDeviceSupport, callInfo)
	mock.lockGpmQueryDeviceSupport.Unlock()
	return mock.GpmQueryDeviceSupportFunc()
}

// GpmQueryDeviceSupportCalls gets all the calls that were made to GpmQueryDeviceSupport.
// Check the length with:
//
//	len(mockedDevice.GpmQueryDeviceSupportCalls())
func (mock *Device) GpmQueryDeviceSupportCalls() []struct {
} {
	var calls []struct {
	}
	mock.lockGpmQueryDeviceSupport.RLock()
	calls = mock.calls.GpmQueryDeviceSupport
	mock.lockGpmQueryDeviceSupport.RUnlock()
	return calls
}

// GpmQueryDeviceSupportV calls GpmQueryDeviceSupportVFunc.
func (mock *Device) GpmQueryDeviceSupportV() nvml.GpmSupportV {
	if mock.GpmQueryDeviceSupportVFunc == nil {
		panic("Device.GpmQueryDeviceSupportVFunc: method is nil but Device.GpmQueryDeviceSupportV was just called")
	}
	callInfo := struct {
	}{}
	mock.lockGpmQueryDeviceSupportV.Lock()
	mock.calls.GpmQueryDeviceSupportV = append(mock.calls.GpmQueryDeviceSupportV, callInfo)
	mock.lockGpmQueryDeviceSupportV.Unlock()
	return mock.GpmQueryDeviceSupportVFunc()
}

// GpmQueryDeviceSupportVCalls gets all the calls that were made to GpmQueryDeviceSupportV.
// Check the length with:
//
//	len(mockedDevice.GpmQueryDeviceSupportVCalls())
func (mock *Device) GpmQueryDeviceSupportVCalls() []struct {
} {
	var calls []struct {
	}
	mock.lockGpmQueryDeviceSupportV.RLock()
	calls = mock.calls.GpmQueryDeviceSupportV
	mock.lockGpmQueryDeviceSupportV.RUnlock()
	return calls
}

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

// GpmQueryIfStreamingEnabledCalls gets all the calls that were made to GpmQueryIfStreamingEnabled.
// Check the length with:
//
//	len(mockedDevice.GpmQueryIfStreamingEnabledCalls())
func (mock *Device) GpmQueryIfStreamingEnabledCalls() []struct {
} {
	var calls []struct {
	}
	mock.lockGpmQueryIfStreamingEnabled.RLock()
	calls = mock.calls.GpmQueryIfStreamingEnabled
	mock.lockGpmQueryIfStreamingEnabled.RUnlock()
	return calls
}

// GpmSampleGet calls GpmSampleGetFunc.
func (mock *Device) GpmSampleGet(gpmSample nvml.GpmSample) nvml.Return {
	if mock.GpmSampleGetFunc == nil {
		panic("Device.GpmSampleGetFunc: method is nil but Device.GpmSampleGet was just called")
	}
	callInfo := struct {
		GpmSample nvml.GpmSample
	}{
		GpmSample: gpmSample,
	}
	mock.lockGpmSampleGet.Lock()
	mock.calls.GpmSampleGet = append(mock.calls.GpmSampleGet, callInfo)
	mock.lockGpmSampleGet.Unlock()
	return mock.GpmSampleGetFunc(gpmSample)
}

// GpmSampleGetCalls gets all the calls that were made to GpmSampleGet.
// Check the length with:
//
//	len(mockedDevice.GpmSampleGetCalls())
func (mock *Device) GpmSampleGetCalls() []struct {
	GpmSample nvml.GpmSample
} {
	var calls []struct {
		GpmSample nvml.GpmSample
	}
	mock.lockGpmSampleGet.RLock()
	calls = mock.calls.GpmSampleGet
	mock.lockGpmSampleGet.RUnlock()
	return calls
}

// GpmSetStreamingEnabled calls GpmSetStreamingEnabledFunc.
func (mock *Device) GpmSetStreamingEnabled(v uint32) nvml.Return {
	if mock.GpmSetStreamingEnabledFunc == nil {
		panic("Device.GpmSetStreamingEnabledFunc: method is nil but Device.GpmSetStreamingEnabled was just called")
	}
	callInfo := struct {
		V uint32
	}{
		V: v,
	}
	mock.lockGpmSetStreamingEnabled.Lock()
	mock.calls.GpmSetStreamingEnabled = append(mock.calls.GpmSetStreamingEnabled, callInfo)
	mock.lockGpmSetStreamingEnabled.Unlock()
	return mock.GpmSetStreamingEnabledFunc(v)
}

// GpmSetStreamingEnabledCalls gets all the calls that were made to GpmSetStreamingEnabled.
// Check the length with:
//
//	len(mockedDevice.GpmSetStreamingEnabledCalls())
func (mock *Device) GpmSetStreamingEnabledCalls() []struct {
	V uint32
} {
	var calls []struct {
		V uint32
	}
	mock.lockGpmSetStreamingEnabled.RLock()
	calls = mock.calls.GpmSetStreamingEnabled
	mock.lockGpmSetStreamingEnabled.RUnlock()
	return calls
}

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

// IsMigDeviceHandleCalls gets all the calls that were made to IsMigDeviceHandle.
// Check the length with:
//
//	len(mockedDevice.IsMigDeviceHandleCalls())
func (mock *Device) IsMigDeviceHandleCalls() []struct {
} {
	var calls []struct {
	}
	mock.lockIsMigDeviceHandle.RLock()
	calls = mock.calls.IsMigDeviceHandle
	mock.lockIsMigDeviceHandle.RUnlock()
	return calls
}

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

// OnSameBoardCalls gets all the calls that were made to OnSameBoard.
// Check the length with:
//
//	len(mockedDevice.OnSameBoardCalls())
func (mock *Device) OnSameBoardCalls() []struct {
	Device nvml.Device
} {
	var calls []struct {
		Device nvml.Device
	}
	mock.lockOnSameBoard.RLock()
	calls = mock.calls.OnSameBoard
	mock.lockOnSameBoard.RUnlock()
	return calls
}

// PowerSmoothingActivatePresetProfile calls PowerSmoothingActivatePresetProfileFunc.
func (mock *Device) PowerSmoothingActivatePresetProfile(powerSmoothingProfile *nvml.PowerSmoothingProfile) nvml.Return {
	if mock.PowerSmoothingActivatePresetProfileFunc == nil {
		panic("Device.PowerSmoothingActivatePresetProfileFunc: method is nil but Device.PowerSmoothingActivatePresetProfile was just called")
	}
	callInfo := struct {
		PowerSmoothingProfile *nvml.PowerSmoothingProfile
	}{
		PowerSmoothingProfile: powerSmoothingProfile,
	}
	mock.lockPowerSmoothingActivatePresetProfile.Lock()
	mock.calls.PowerSmoothingActivatePresetProfile = append(mock.calls.PowerSmoothingActivatePresetProfile, callInfo)
	mock.lockPowerSmoothingActivatePresetProfile.Unlock()
	return mock.PowerSmoothingActivatePresetProfileFunc(powerSmoothingProfile)
}

// PowerSmoothingActivatePresetProfileCalls gets all the calls that were made to PowerSmoothingActivatePresetProfile.
// Check the length with:
//
//	len(mockedDevice.PowerSmoothingActivatePresetProfileCalls())
func (mock *Device) PowerSmoothingActivatePresetProfileCalls() []struct {
	PowerSmoothingProfile *nvml.PowerSmoothingProfile
} {
	var calls []struct {
		PowerSmoothingProfile *nvml.PowerSmoothingProfile
	}
	mock.lockPowerSmoothingActivatePresetProfile.RLock()
	calls = mock.calls.PowerSmoothingActivatePresetProfile
	mock.lockPowerSmoothingActivatePresetProfile.RUnlock()
	return calls
}

// PowerSmoothingSetState calls PowerSmoothingSetStateFunc.
func (mock *Device) PowerSmoothingSetState(powerSmoothingState *nvml.PowerSmoothingState) nvml.Return {
	if mock.PowerSmoothingSetStateFunc == nil {
		panic("Device.PowerSmoothingSetStateFunc: method is nil but Device.PowerSmoothingSetState was just called")
	}
	callInfo := struct {
		PowerSmoothingState *nvml.PowerSmoothingState
	}{
		PowerSmoothingState: powerSmoothingState,
	}
	mock.lockPowerSmoothingSetState.Lock()
	mock.calls.PowerSmoothingSetState = append(mock.calls.PowerSmoothingSetState, callInfo)
	mock.lockPowerSmoothingSetState.Unlock()
	return mock.PowerSmoothingSetStateFunc(powerSmoothingState)
}

// PowerSmoothingSetStateCalls gets all the calls that were made to PowerSmoothingSetState.
// Check the length with:
//
//	len(mockedDevice.PowerSmoothingSetStateCalls())
func (mock *Device) PowerSmoothingSetStateCalls() []struct {
	PowerSmoothingState *nvml.PowerSmoothingState
} {
	var calls []struct {
		PowerSmoothingState *nvml.PowerSmoothingState
	}
	mock.lockPowerSmoothingSetState.RLock()
	calls = mock.calls.PowerSmoothingSetState
	mock.lockPowerSmoothingSetState.RUnlock()
	return calls
}

// PowerSmoothingUpdatePresetProfileParam calls PowerSmoothingUpdatePresetProfileParamFunc.
func (mock *Device) PowerSmoothingUpdatePresetProfileParam(powerSmoothingProfile *nvml.PowerSmoothingProfile) nvml.Return {
	if mock.PowerSmoothingUpdatePresetProfileParamFunc == nil {
		panic("Device.PowerSmoothingUpdatePresetProfileParamFunc: method is nil but Device.PowerSmoothingUpdatePresetProfileParam was just called")
	}
	callInfo := struct {
		PowerSmoothingProfile *nvml.PowerSmoothingProfile
	}{
		PowerSmoothingProfile: powerSmoothingProfile,
	}
	mock.lockPowerSmoothingUpdatePresetProfileParam.Lock()
	mock.calls.PowerSmoothingUpdatePresetProfileParam = append(mock.calls.PowerSmoothingUpdatePresetProfileParam, callInfo)
	mock.lockPowerSmoothingUpdatePresetProfileParam.Unlock()
	return mock.PowerSmoothingUpdatePresetProfileParamFunc(powerSmoothingProfile)
}

// PowerSmoothingUpdatePresetProfileParamCalls gets all the calls that were made to PowerSmoothingUpdatePresetProfileParam.
// Check the length with:
//
//	len(mockedDevice.PowerSmoothingUpdatePresetProfileParamCalls())
func (mock *Device) PowerSmoothingUpdatePresetProfileParamCalls() []struct {
	PowerSmoothingProfile *nvml.PowerSmoothingProfile
} {
	var calls []struct {
		PowerSmoothingProfile *nvml.PowerSmoothingProfile
	}
	mock.lockPowerSmoothingUpdatePresetProfileParam.RLock()
	calls = mock.calls.PowerSmoothingUpdatePresetProfileParam
	mock.lockPowerSmoothingUpdatePresetProfileParam.RUnlock()
	return calls
}

// ReadWritePRM_v1 calls ReadWritePRM_v1Func.
func (mock *Device) ReadWritePRM_v1(pRMTLV_v1 *nvml.PRMTLV_v1) nvml.Return {
	if mock.ReadWritePRM_v1Func == nil {
		panic("Device.ReadWritePRM_v1Func: method is nil but Device.ReadWritePRM_v1 was just called")
	}
	callInfo := struct {
		PRMTLV_v1 *nvml.PRMTLV_v1
	}{
		PRMTLV_v1: pRMTLV_v1,
	}
	mock.lockReadWritePRM_v1.Lock()
	mock.calls.ReadWritePRM_v1 = append(mock.calls.ReadWritePRM_v1, callInfo)
	mock.lockReadWritePRM_v1.Unlock()
	return mock.ReadWritePRM_v1Func(pRMTLV_v1)
}

// ReadWritePRM_v1Calls gets all the calls that were made to ReadWritePRM_v1.
// Check the length with:
//
//	len(mockedDevice.ReadWritePRM_v1Calls())
func (mock *Device) ReadWritePRM_v1Calls() []struct {
	PRMTLV_v1 *nvml.PRMTLV_v1
} {
	var calls []struct {
		PRMTLV_v1 *nvml.PRMTLV_v1
	}
	mock.lockReadWritePRM_v1.RLock()
	calls = mock.calls.ReadWritePRM_v1
	mock.lockReadWritePRM_v1.RUnlock()
	return calls
}

// RegisterEvents calls RegisterEventsFunc.
func (mock *Device) RegisterEvents(v uint64, eventSet nvml.EventSet) nvml.Return {
	if mock.RegisterEventsFunc == nil {
		panic("Device.RegisterEventsFunc: method is nil but Device.RegisterEvents was just called")
	}
	callInfo := struct {
		V        uint64
		EventSet nvml.EventSet
	}{
		V:        v,
		EventSet: eventSet,
	}
	mock.lockRegisterEvents.Lock()
	mock.calls.RegisterEvents = append(mock.calls.RegisterEvents, callInfo)
	mock.lockRegisterEvents.Unlock()
	return mock.RegisterEventsFunc(v, eventSet)
}

// RegisterEventsCalls gets all the calls that were made to RegisterEvents.
// Check the length with:
//
//	len(mockedDevice.RegisterEventsCalls())
func (mock *Device) RegisterEventsCalls() []struct {
	V        uint64
	EventSet nvml.EventSet
} {
	var calls []struct {
		V        uint64
		EventSet nvml.EventSet
	}
	mock.lockRegisterEvents.RLock()
	calls = mock.calls.RegisterEvents
	mock.lockRegisterEvents.RUnlock()
	return calls
}

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

// ResetApplicationsClocksCalls gets all the calls that were made to ResetApplicationsClocks.
// Check the length with:
//
//	len(mockedDevice.ResetApplicationsClocksCalls())
func (mock *Device) ResetApplicationsClocksCalls() []struct {
} {
	var calls []struct {
	}
	mock.lockResetApplicationsClocks.RLock()
	calls = mock.calls.ResetApplicationsClocks
	mock.lockResetApplicationsClocks.RUnlock()
	return calls
}

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

// ResetGpuLockedClocksCalls gets all the calls that were made to ResetGpuLockedClocks.
// Check the length with:
//
//	len(mockedDevice.ResetGpuLockedClocksCalls())
func (mock *Device) ResetGpuLockedClocksCalls() []struct {
} {
	var calls []struct {
	}
	mock.lockResetGpuLockedClocks.RLock()
	calls = mock.calls.ResetGpuLockedClocks
	mock.lockResetGpuLockedClocks.RUnlock()
	return calls
}

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

// ResetMemoryLockedClocksCalls gets all the calls that were made to ResetMemoryLockedClocks.
// Check the length with:
//
//	len(mockedDevice.ResetMemoryLockedClocksCalls())
func (mock *Device) ResetMemoryLockedClocksCalls() []struct {
} {
	var calls []struct {
	}
	mock.lockResetMemoryLockedClocks.RLock()
	calls = mock.calls.ResetMemoryLockedClocks
	mock.lockResetMemoryLockedClocks.RUnlock()
	return calls
}

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

// ResetNvLinkErrorCountersCalls gets all the calls that were made to ResetNvLinkErrorCounters.
// Check the length with:
//
//	len(mockedDevice.ResetNvLinkErrorCountersCalls())
func (mock *Device) ResetNvLinkErrorCountersCalls() []struct {
	N int
} {
	var calls []struct {
		N int
	}
	mock.lockResetNvLinkErrorCounters.RLock()
	calls = mock.calls.ResetNvLinkErrorCounters
	mock.lockResetNvLinkErrorCounters.RUnlock()
	return calls
}

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

// ResetNvLinkUtilizationCounterCalls gets all the calls that were made to ResetNvLinkUtilizationCounter.
// Check the length with:
//
//	len(mockedDevice.ResetNvLinkUtilizationCounterCalls())
func (mock *Device) ResetNvLinkUtilizationCounterCalls() []struct {
	N1 int
	N2 int
} {
	var calls []struct {
		N1 int
		N2 int
	}
	mock.lockResetNvLinkUtilizationCounter.RLock()
	calls = mock.calls.ResetNvLinkUtilizationCounter
	mock.lockResetNvLinkUtilizationCounter.RUnlock()
	return calls
}

// SetAPIRestriction calls SetAPIRestrictionFunc.
func (mock *Device) SetAPIRestriction(restrictedAPI nvml.RestrictedAPI, enableState nvml.EnableState) nvml.Return {
	if mock.SetAPIRestrictionFunc == nil {
		panic("Device.SetAPIRestrictionFunc: method is nil but Device.SetAPIRestriction was just called")
	}
	callInfo := struct {
		RestrictedAPI nvml.RestrictedAPI
		EnableState   nvml.EnableState
	}{
		RestrictedAPI: restrictedAPI,
		EnableState:   enableState,
	}
	mock.lockSetAPIRestriction.Lock()
	mock.calls.SetAPIRestriction = append(mock.calls.SetAPIRestriction, callInfo)
	mock.lockSetAPIRestriction.Unlock()
	return mock.SetAPIRestrictionFunc(restrictedAPI, enableState)
}

// SetAPIRestrictionCalls gets all the calls that were made to SetAPIRestriction.
// Check the length with:
//
//	len(mockedDevice.SetAPIRestrictionCalls())
func (mock *Device) SetAPIRestrictionCalls() []struct {
	RestrictedAPI nvml.RestrictedAPI
	EnableState   nvml.EnableState
} {
	var calls []struct {
		RestrictedAPI nvml.RestrictedAPI
		EnableState   nvml.EnableState
	}
	mock.lockSetAPIRestriction.RLock()
	calls = mock.calls.SetAPIRestriction
	mock.lockSetAPIRestriction.RUnlock()
	return calls
}

// SetAccountingMode calls SetAccountingModeFunc.
func (mock *Device) SetAccountingMode(enableState nvml.EnableState) nvml.Return {
	if mock.SetAccountingModeFunc == nil {
		panic("Device.SetAccountingModeFunc: method is nil but Device.SetAccountingMode was just called")
	}
	callInfo := struct {
		EnableState nvml.EnableState
	}{
		EnableState: enableState,
	}
	mock.lockSetAccountingMode.Lock()
	mock.calls.SetAccountingMode = append(mock.calls.SetAccountingMode, callInfo)
	mock.lockSetAccountingMode.Unlock()
	return mock.SetAccountingModeFunc(enableState)
}

// SetAccountingModeCalls gets all the calls that were made to SetAccountingMode.
// Check the length with:
//
//	len(mockedDevice.SetAccountingModeCalls())
func (mock *Device) SetAccountingModeCalls() []struct {
	EnableState nvml.EnableState
} {
	var calls []struct {
		EnableState nvml.EnableState
	}
	mock.lockSetAccountingMode.RLock()
	calls = mock.calls.SetAccountingMode
	mock.lockSetAccountingMode.RUnlock()
	return calls
}

// SetApplicationsClocks calls SetApplicationsClocksFunc.
func (mock *Device) SetApplicationsClocks(v1 uint32, v2 uint32) nvml.Return {
	if mock.SetApplicationsClocksFunc == nil {
		panic("Device.SetApplicationsClocksFunc: method is nil but Device.SetApplicationsClocks was just called")
	}
	callInfo := struct {
		V1 uint32
		V2 uint32
	}{
		V1: v1,
		V2: v2,
	}
	mock.lockSetApplicationsClocks.Lock()
	mock.calls.SetApplicationsClocks = append(mock.calls.SetApplicationsClocks, callInfo)
	mock.lockSetApplicationsClocks.Unlock()
	return mock.SetApplicationsClocksFunc(v1, v2)
}

// SetApplicationsClocksCalls gets all the calls that were made to SetApplicationsClocks.
// Check the length with:
//
//	len(mockedDevice.SetApplicationsClocksCalls())
func (mock *Device) SetApplicationsClocksCalls() []struct {
	V1 uint32
	V2 uint32
} {
	var calls []struct {
		V1 uint32
		V2 uint32
	}
	mock.lockSetApplicationsClocks.RLock()
	calls = mock.calls.SetApplicationsClocks
	mock.lockSetApplicationsClocks.RUnlock()
	return calls
}

// SetAutoBoostedClocksEnabled calls SetAutoBoostedClocksEnabledFunc.
func (mock *Device) SetAutoBoostedClocksEnabled(enableState nvml.EnableState) nvml.Return {
	if mock.SetAutoBoostedClocksEnabledFunc == nil {
		panic("Device.SetAutoBoostedClocksEnabledFunc: method is nil but Device.SetAutoBoostedClocksEnabled was just called")
	}
	callInfo := struct {
		EnableState nvml.EnableState
	}{
		EnableState: enableState,
	}
	mock.lockSetAutoBoostedClocksEnabled.Lock()
	mock.calls.SetAutoBoostedClocksEnabled = append(mock.calls.SetAutoBoostedClocksEnabled, callInfo)
	mock.lockSetAutoBoostedClocksEnabled.Unlock()
	return mock.SetAutoBoostedClocksEnabledFunc(enableState)
}

// SetAutoBoostedClocksEnabledCalls gets all the calls that were made to SetAutoBoostedClocksEnabled.
// Check the length with:
//
//	len(mockedDevice.SetAutoBoostedClocksEnabledCalls())
func (mock *Device) SetAutoBoostedClocksEnabledCalls() []struct {
	EnableState nvml.EnableState
} {
	var calls []struct {
		EnableState nvml.EnableState
	}
	mock.lockSetAutoBoostedClocksEnabled.RLock()
	calls = mock.calls.SetAutoBoostedClocksEnabled
	mock.lockSetAutoBoostedClocksEnabled.RUnlock()
	return calls
}

// SetClockOffsets calls SetClockOffsetsFunc.
func (mock *Device) SetClockOffsets(clockOffset nvml.ClockOffset) nvml.Return {
	if mock.SetClockOffsetsFunc == nil {
		panic("Device.SetClockOffsetsFunc: method is nil but Device.SetClockOffsets was just called")
	}
	callInfo := struct {
		ClockOffset nvml.ClockOffset
	}{
		ClockOffset: clockOffset,
	}
	mock.lockSetClockOffsets.Lock()
	mock.calls.SetClockOffsets = append(mock.calls.SetClockOffsets, callInfo)
	mock.lockSetClockOffsets.Unlock()
	return mock.SetClockOffsetsFunc(clockOffset)
}

// SetClockOffsetsCalls gets all the calls that were made to SetClockOffsets.
// Check the length with:
//
//	len(mockedDevice.SetClockOffsetsCalls())
func (mock *Device) SetClockOffsetsCalls() []struct {
	ClockOffset nvml.ClockOffset
} {
	var calls []struct {
		ClockOffset nvml.ClockOffset
	}
	mock.lockSetClockOffsets.RLock()
	calls = mock.calls.SetClockOffsets
	mock.lockSetClockOffsets.RUnlock()
	return calls
}

// SetComputeMode calls SetComputeModeFunc.
func (mock *Device) SetComputeMode(computeMode nvml.ComputeMode) nvml.Return {
	if mock.SetComputeModeFunc == nil {
		panic("Device.SetComputeModeFunc: method is nil but Device.SetComputeMode was just called")
	}
	callInfo := struct {
		ComputeMode nvml.ComputeMode
	}{
		ComputeMode: computeMode,
	}
	mock.lockSetComputeMode.Lock()
	mock.calls.SetComputeMode = append(mock.calls.SetComputeMode, callInfo)
	mock.lockSetComputeMode.Unlock()
	return mock.SetComputeModeFunc(computeMode)
}

// SetComputeModeCalls gets all the calls that were made to SetComputeMode.
// Check the length with:
//
//	len(mockedDevice.SetComputeModeCalls())
func (mock *Device) SetComputeModeCalls() []struct {
	ComputeMode nvml.ComputeMode
} {
	var calls []struct {
		ComputeMode nvml.ComputeMode
	}
	mock.lockSetComputeMode.RLock()
	calls = mock.calls.SetComputeMode
	mock.lockSetComputeMode.RUnlock()
	return calls
}

// SetConfComputeUnprotectedMemSize calls SetConfComputeUnprotectedMemSizeFunc.
func (mock *Device) SetConfComputeUnprotectedMemSize(v uint64) nvml.Return {
	if mock.SetConfComputeUnprotectedMemSizeFunc == nil {
		panic("Device.SetConfComputeUnprotectedMemSizeFunc: method is nil but Device.SetConfComputeUnprotectedMemSize was just called")
	}
	callInfo := struct {
		V uint64
	}{
		V: v,
	}
	mock.lockSetConfComputeUnprotectedMemSize.Lock()
	mock.calls.SetConfComputeUnprotectedMemSize = append(mock.calls.SetConfComputeUnprotectedMemSize, callInfo)
	mock.lockSetConfComputeUnprotectedMemSize.Unlock()
	return mock.SetConfComputeUnprotectedMemSizeFunc(v)
}

// SetConfComputeUnprotectedMemSizeCalls gets all the calls that were made to SetConfComputeUnprotectedMemSize.
// Check the length with:
//
//	len(mockedDevice.SetConfComputeUnprotectedMemSizeCalls())
func (mock *Device) SetConfComputeUnprotectedMemSizeCalls() []struct {
	V uint64
} {
	var calls []struct {
		V uint64
	}
	mock.lockSetConfComputeUnprotectedMemSize.RLock()
	calls = mock.calls.SetConfComputeUnprotectedMemSize
	mock.lockSetConfComputeUnprotectedMemSize.RUnlock()
	return calls
}

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

// SetCpuAffinityCalls gets all the calls that were made to SetCpuAffinity.
// Check the length with:
//
//	len(mockedDevice.SetCpuAffinityCalls())
func (mock *Device) SetCpuAffinityCalls() []struct {
} {
	var calls []struct {
	}
	mock.lockSetCpuAffinity.RLock()
	calls = mock.calls.SetCpuAffinity
	mock.lockSetCpuAffinity.RUnlock()
	return calls
}

// SetDefaultAutoBoostedClocksEnabled calls SetDefaultAutoBoostedClocksEnabledFunc.
func (mock *Device) SetDefaultAutoBoostedClocksEnabled(enableState nvml.EnableState, v uint32) nvml.Return {
	if mock.SetDefaultAutoBoostedClocksEnabledFunc == nil {
		panic("Device.SetDefaultAutoBoostedClocksEnabledFunc: method is nil but Device.SetDefaultAutoBoostedClocksEnabled was just called")
	}
	callInfo := struct {
		EnableState nvml.EnableState
		V           uint32
	}{
		EnableState: enableState,
		V:           v,
	}
	mock.lockSetDefaultAutoBoostedClocksEnabled.Lock()
	mock.calls.SetDefaultAutoBoostedClocksEnabled = append(mock.calls.SetDefaultAutoBoostedClocksEnabled, callInfo)
	mock.lockSetDefaultAutoBoostedClocksEnabled.Unlock()
	return mock.SetDefaultAutoBoostedClocksEnabledFunc(enableState, v)
}

// SetDefaultAutoBoostedClocksEnabledCalls gets all the calls that were made to SetDefaultAutoBoostedClocksEnabled.
// Check the length with:
//
//	len(mockedDevice.SetDefaultAutoBoostedClocksEnabledCalls())
func (mock *Device) SetDefaultAutoBoostedClocksEnabledCalls() []struct {
	EnableState nvml.EnableState
	V           uint32
} {
	var calls []struct {
		EnableState nvml.EnableState
		V           uint32
	}
	mock.lockSetDefaultAutoBoostedClocksEnabled.RLock()
	calls = mock.calls.SetDefaultAutoBoostedClocksEnabled
	mock.lockSetDefaultAutoBoostedClocksEnabled.RUnlock()
	return calls
}

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

// SetDefaultFanSpeed_v2Calls gets all the calls that were made to SetDefaultFanSpeed_v2.
// Check the length with:
//
//	len(mockedDevice.SetDefaultFanSpeed_v2Calls())
func (mock *Device) SetDefaultFanSpeed_v2Calls() []struct {
	N int
} {
	var calls []struct {
		N int
	}
	mock.lockSetDefaultFanSpeed_v2.RLock()
	calls = mock.calls.SetDefaultFanSpeed_v2
	mock.lockSetDefaultFanSpeed_v2.RUnlock()
	return calls
}

// SetDramEncryptionMode calls SetDramEncryptionModeFunc.
func (mock *Device) SetDramEncryptionMode(dramEncryptionInfo *nvml.DramEncryptionInfo) nvml.Return {
	if mock.SetDramEncryptionModeFunc == nil {
		panic("Device.SetDramEncryptionModeFunc: method is nil but Device.SetDramEncryptionMode was just called")
	}
	callInfo := struct {
		DramEncryptionInfo *nvml.DramEncryptionInfo
	}{
		DramEncryptionInfo: dramEncryptionInfo,
	}
	mock.lockSetDramEncryptionMode.Lock()
	mock.calls.SetDramEncryptionMode = append(mock.calls.SetDramEncryptionMode, callInfo)
	mock.lockSetDramEncryptionMode.Unlock()
	return mock.SetDramEncryptionModeFunc(dramEncryptionInfo)
}

// SetDramEncryptionModeCalls gets all the calls that were made to SetDramEncryptionMode.
// Check the length with:
//
//	len(mockedDevice.SetDramEncryptionModeCalls())
func (mock *Device) SetDramEncryptionModeCalls() []struct {
	DramEncryptionInfo *nvml.DramEncryptionInfo
} {
	var calls []struct {
		DramEncryptionInfo *nvml.DramEncryptionInfo
	}
	mock.lockSetDramEncryptionMode.RLock()
	calls = mock.calls.SetDramEncryptionMode
	mock.lockSetDramEncryptionMode.RUnlock()
	return calls
}

// SetDriverModel calls SetDriverModelFunc.
func (mock *Device) SetDriverModel(driverModel nvml.DriverModel, v uint32) nvml.Return {
	if mock.SetDriverModelFunc == nil {
		panic("Device.SetDriverModelFunc: method is nil but Device.SetDriverModel was just called")
	}
	callInfo := struct {
		DriverModel nvml.DriverModel
		V           uint32
	}{
		DriverModel: driverModel,
		V:           v,
	}
	mock.lockSetDriverModel.Lock()
	mock.calls.SetDriverModel = append(mock.calls.SetDriverModel, callInfo)
	mock.lockSetDriverModel.Unlock()
	return mock.SetDriverModelFunc(driverModel, v)
}

// SetDriverModelCalls gets all the calls that were made to SetDriverModel.
// Check the length with:
//
//	len(mockedDevice.SetDriverModelCalls())
func (mock *Device) SetDriverModelCalls() []struct {
	DriverModel nvml.DriverModel
	V           uint32
} {
	var calls []struct {
		DriverModel nvml.DriverModel
		V           uint32
	}
	mock.lockSetDriverModel.RLock()
	calls = mock.calls.SetDriverModel
	mock.lockSetDriverModel.RUnlock()
	return calls
}

// SetEccMode calls SetEccModeFunc.
func (mock *Device) SetEccMode(enableState nvml.EnableState) nvml.Return {
	if mock.SetEccModeFunc == nil {
		panic("Device.SetEccModeFunc: method is nil but Device.SetEccMode was just called")
	}
	callInfo := struct {
		EnableState nvml.EnableState
	}{
		EnableState: enableState,
	}
	mock.lockSetEccMode.Lock()
	mock.calls.SetEccMode = append(mock.calls.SetEccMode, callInfo)
	mock.lockSetEccMode.Unlock()
	return mock.SetEccModeFunc(enableState)
}

// SetEccModeCalls gets all the calls that were made to SetEccMode.
// Check the length with:
//
//	len(mockedDevice.SetEccModeCalls())
func (mock *Device) SetEccModeCalls() []struct {
	EnableState nvml.EnableState
} {
	var calls []struct {
		EnableState nvml.EnableState
	}
	mock.lockSetEccMode.RLock()
	calls = mock.calls.SetEccMode
	mock.lockSetEccMode.RUnlock()
	return calls
}

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

// SetFanControlPolicyCalls gets all the calls that were made to SetFanControlPolicy.
// Check the length with:
//
//	len(mockedDevice.SetFanControlPolicyCalls())
func (mock *Device) SetFanControlPolicyCalls() []struct {
	N                int
	FanControlPolicy nvml.FanControlPolicy
} {
	var calls []struct {
		N                int
		FanControlPolicy nvml.FanControlPolicy
	}
	mock.lockSetFanControlPolicy.RLock()
	calls = mock.calls.SetFanControlPolicy
	mock.lockSetFanControlPolicy.RUnlock()
	return calls
}

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

// SetFanSpeed_v2Calls gets all the calls that were made to SetFanSpeed_v2.
// Check the length with:
//
//	len(mockedDevice.SetFanSpeed_v2Calls())
func (mock *Device) SetFanSpeed_v2Calls() []struct {
	N1 int
	N2 int
} {
	var calls []struct {
		N1 int
		N2 int
	}
	mock.lockSetFanSpeed_v2.RLock()
	calls = mock.calls.SetFanSpeed_v2
	mock.lockSetFanSpeed_v2.RUnlock()
	return calls
}

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

// SetGpcClkVfOffsetCalls gets all the calls that were made to SetGpcClkVfOffset.
// Check the length with:
//
//	len(mockedDevice.SetGpcClkVfOffsetCalls())
func (mock *Device) SetGpcClkVfOffsetCalls() []struct {
	N int
} {
	var calls []struct {
		N int
	}
	mock.lockSetGpcClkVfOffset.RLock()
	calls = mock.calls.SetGpcClkVfOffset
	mock.lockSetGpcClkVfOffset.RUnlock()
	return calls
}

// SetGpuLockedClocks calls SetGpuLockedClocksFunc.
func (mock *Device) SetGpuLockedClocks(v1 uint32, v2 uint32) nvml.Return {
	if mock.SetGpuLockedClocksFunc == nil {
		panic("Device.SetGpuLockedClocksFunc: method is nil but Device.SetGpuLockedClocks was just called")
	}
	callInfo := struct {
		V1 uint32
		V2 uint32
	}{
		V1: v1,
		V2: v2,
	}
	mock.lockSetGpuLockedClocks.Lock()
	mock.calls.SetGpuLockedClocks = append(mock.calls.SetGpuLockedClocks, callInfo)
	mock.lockSetGpuLockedClocks.Unlock()
	return mock.SetGpuLockedClocksFunc(v1, v2)
}

// SetGpuLockedClocksCalls gets all the calls that were made to SetGpuLockedClocks.
// Check the length with:
//
//	len(mockedDevice.SetGpuLockedClocksCalls())
func (mock *Device) SetGpuLockedClocksCalls() []struct {
	V1 uint32
	V2 uint32
} {
	var calls []struct {
		V1 uint32
		V2 uint32
	}
	mock.lockSetGpuLockedClocks.RLock()
	calls = mock.calls.SetGpuLockedClocks
	mock.lockSetGpuLockedClocks.RUnlock()
	return calls
}

// SetGpuOperationMode calls SetGpuOperationModeFunc.
func (mock *Device) SetGpuOperationMode(gpuOperationMode nvml.GpuOperationMode) nvml.Return {
	if mock.SetGpuOperationModeFunc == nil {
		panic("Device.SetGpuOperationModeFunc: method is nil but Device.SetGpuOperationMode was just called")
	}
	callInfo := struct {
		GpuOperationMode nvml.GpuOperationMode
	}{
		GpuOperationMode: gpuOperationMode,
	}
	mock.lockSetGpuOperationMode.Lock()
	mock.calls.SetGpuOperationMode = append(mock.calls.SetGpuOperationMode, callInfo)
	mock.lockSetGpuOperationMode.Unlock()
	return mock.SetGpuOperationModeFunc(gpuOperationMode)
}

// SetGpuOperationModeCalls gets all the calls that were made to SetGpuOperationMode.
// Check the length with:
//
//	len(mockedDevice.SetGpuOperationModeCalls())
func (mock *Device) SetGpuOperationModeCalls() []struct {
	GpuOperationMode nvml.GpuOperationMode
} {
	var calls []struct {
		GpuOperationMode nvml.GpuOperationMode
	}
	mock.lockSetGpuOperationMode.RLock()
	calls = mock.calls.SetGpuOperationMode
	mock.lockSetGpuOperationMode.RUnlock()
	return calls
}

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

// SetMemClkVfOffsetCalls gets all the calls that were made to SetMemClkVfOffset.
// Check the length with:
//
//	len(mockedDevice.SetMemClkVfOffsetCalls())
func (mock *Device) SetMemClkVfOffsetCalls() []struct {
	N int
} {
	var calls []struct {
		N int
	}
	mock.lockSetMemClkVfOffset.RLock()
	calls = mock.calls.SetMemClkVfOffset
	mock.lockSetMemClkVfOffset.RUnlock()
	return calls
}

// SetMemoryLockedClocks calls SetMemoryLockedClocksFunc.
func (mock *Device) SetMemoryLockedClocks(v1 uint32, v2 uint32) nvml.Return {
	if mock.SetMemoryLockedClocksFunc == nil {
		panic("Device.SetMemoryLockedClocksFunc: method is nil but Device.SetMemoryLockedClocks was just called")
	}
	callInfo := struct {
		V1 uint32
		V2 uint32
	}{
		V1: v1,
		V2: v2,
	}
	mock.lockSetMemoryLockedClocks.Lock()
	mock.calls.SetMemoryLockedClocks = append(mock.calls.SetMemoryLockedClocks, callInfo)
	mock.lockSetMemoryLockedClocks.Unlock()
	return mock.SetMemoryLockedClocksFunc(v1, v2)
}

// SetMemoryLockedClocksCalls gets all the calls that were made to SetMemoryLockedClocks.
// Check the length with:
//
//	len(mockedDevice.SetMemoryLockedClocksCalls())
func (mock *Device) SetMemoryLockedClocksCalls() []struct {
	V1 uint32
	V2 uint32
} {
	var calls []struct {
		V1 uint32
		V2 uint32
	}
	mock.lockSetMemoryLockedClocks.RLock()
	calls = mock.calls.SetMemoryLockedClocks
	mock.lockSetMemoryLockedClocks.RUnlock()
	return calls
}

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

// SetMigModeCalls gets all the calls that were made to SetMigMode.
// Check the length with:
//
//	len(mockedDevice.SetMigModeCalls())
func (mock *Device) SetMigModeCalls() []struct {
	N int
} {
	var calls []struct {
		N int
	}
	mock.lockSetMigMode.RLock()
	calls = mock.calls.SetMigMode
	mock.lockSetMigMode.RUnlock()
	return calls
}

// SetNvLinkDeviceLowPowerThreshold calls SetNvLinkDeviceLowPowerThresholdFunc.
func (mock *Device) SetNvLinkDeviceLowPowerThreshold(nvLinkPowerThres *nvml.NvLinkPowerThres) nvml.Return {
	if mock.SetNvLinkDeviceLowPowerThresholdFunc == nil {
		panic("Device.SetNvLinkDeviceLowPowerThresholdFunc: method is nil but Device.SetNvLinkDeviceLowPowerThreshold was just called")
	}
	callInfo := struct {
		NvLinkPowerThres *nvml.NvLinkPowerThres
	}{
		NvLinkPowerThres: nvLinkPowerThres,
	}
	mock.lockSetNvLinkDeviceLowPowerThreshold.Lock()
	mock.calls.SetNvLinkDeviceLowPowerThreshold = append(mock.calls.SetNvLinkDeviceLowPowerThreshold, callInfo)
	mock.lockSetNvLinkDeviceLowPowerThreshold.Unlock()
	return mock.SetNvLinkDeviceLowPowerThresholdFunc(nvLinkPowerThres)
}

// SetNvLinkDeviceLowPowerThresholdCalls gets all the calls that were made to SetNvLinkDeviceLowPowerThreshold.
// Check the length with:
//
//	len(mockedDevice.SetNvLinkDeviceLowPowerThresholdCalls())
func (mock *Device) SetNvLinkDeviceLowPowerThresholdCalls() []struct {
	NvLinkPowerThres *nvml.NvLinkPowerThres
} {
	var calls []struct {
		NvLinkPowerThres *nvml.NvLinkPowerThres
	}
	mock.lockSetNvLinkDeviceLowPowerThreshold.RLock()
	calls = mock.calls.SetNvLinkDeviceLowPowerThreshold
	mock.lockSetNvLinkDeviceLowPowerThreshold.RUnlock()
	return calls
}

// SetNvLinkUtilizationControl calls SetNvLinkUtilizationControlFunc.
func (mock *Device) SetNvLinkUtilizationControl(n1 int, n2 int, nvLinkUtilizationControl *nvml.NvLinkUtilizationControl, b bool) nvml.Return {
	if mock.SetNvLinkUtilizationControlFunc == nil {
		panic("Device.SetNvLinkUtilizationControlFunc: method is nil but Device.SetNvLinkUtilizationControl was just called")
	}
	callInfo := struct {
		N1                       int
		N2                       int
		NvLinkUtilizationControl *nvml.NvLinkUtilizationControl
		B                        bool
	}{
		N1:                       n1,
		N2:                       n2,
		NvLinkUtilizationControl: nvLinkUtilizationControl,
		B:                        b,
	}
	mock.lockSetNvLinkUtilizationControl.Lock()
	mock.calls.SetNvLinkUtilizationControl = append(mock.calls.SetNvLinkUtilizationControl, callInfo)
	mock.lockSetNvLinkUtilizationControl.Unlock()
	return mock.SetNvLinkUtilizationControlFunc(n1, n2, nvLinkUtilizationControl, b)
}

// SetNvLinkUtilizationControlCalls gets all the calls that were made to SetNvLinkUtilizationControl.
// Check the length with:
//
//	len(mockedDevice.SetNvLinkUtilizationControlCalls())
func (mock *Device) SetNvLinkUtilizationControlCalls() []struct {
	N1                       int
	N2                       int
	NvLinkUtilizationControl *nvml.NvLinkUtilizationControl
	B                        bool
} {
	var calls []struct {
		N1                       int
		N2                       int
		NvLinkUtilizationControl *nvml.NvLinkUtilizationControl
		B                        bool
	}
	mock.lockSetNvLinkUtilizationControl.RLock()
	calls = mock.calls.SetNvLinkUtilizationControl
	mock.lockSetNvLinkUtilizationControl.RUnlock()
	return calls
}

// SetNvlinkBwMode calls SetNvlinkBwModeFunc.
func (mock *Device) SetNvlinkBwMode(nvlinkSetBwMode *nvml.NvlinkSetBwMode) nvml.Return {
	if mock.SetNvlinkBwModeFunc == nil {
		panic("Device.SetNvlinkBwModeFunc: method is nil but Device.SetNvlinkBwMode was just called")
	}
	callInfo := struct {
		NvlinkSetBwMode *nvml.NvlinkSetBwMode
	}{
		NvlinkSetBwMode: nvlinkSetBwMode,
	}
	mock.lockSetNvlinkBwMode.Lock()
	mock.calls.SetNvlinkBwMode = append(mock.calls.SetNvlinkBwMode, callInfo)
	mock.lockSetNvlinkBwMode.Unlock()
	return mock.SetNvlinkBwModeFunc(nvlinkSetBwMode)
}

// SetNvlinkBwModeCalls gets all the calls that were made to SetNvlinkBwMode.
// Check the length with:
//
//	len(mockedDevice.SetNvlinkBwModeCalls())
func (mock *Device) SetNvlinkBwModeCalls() []struct {
	NvlinkSetBwMode *nvml.NvlinkSetBwMode
} {
	var calls []struct {
		NvlinkSetBwMode *nvml.NvlinkSetBwMode
	}
	mock.lockSetNvlinkBwMode.RLock()
	calls = mock.calls.SetNvlinkBwMode
	mock.lockSetNvlinkBwMode.RUnlock()
	return calls
}

// SetPersistenceMode calls SetPersistenceModeFunc.
func (mock *Device) SetPersistenceMode(enableState nvml.EnableState) nvml.Return {
	if mock.SetPersistenceModeFunc == nil {
		panic("Device.SetPersistenceModeFunc: method is nil but Device.SetPersistenceMode was just called")
	}
	callInfo := struct {
		EnableState nvml.EnableState
	}{
		EnableState: enableState,
	}
	mock.lockSetPersistenceMode.Lock()
	mock.calls.SetPersistenceMode = append(mock.calls.SetPersistenceMode, callInfo)
	mock.lockSetPersistenceMode.Unlock()
	return mock.SetPersistenceModeFunc(enableState)
}

// SetPersistenceModeCalls gets all the calls that were made to SetPersistenceMode.
// Check the length with:
//
//	len(mockedDevice.SetPersistenceModeCalls())
func (mock *Device) SetPersistenceModeCalls() []struct {
	EnableState nvml.EnableState
} {
	var calls []struct {
		EnableState nvml.EnableState
	}
	mock.lockSetPersistenceMode.RLock()
	calls = mock.calls.SetPersistenceMode
	mock.lockSetPersistenceMode.RUnlock()
	return calls
}

// SetPowerManagementLimit calls SetPowerManagementLimitFunc.
func (mock *Device) SetPowerManagementLimit(v uint32) nvml.Return {
	if mock.SetPowerManagementLimitFunc == nil {
		panic("Device.SetPowerManagementLimitFunc: method is nil but Device.SetPowerManagementLimit was just called")
	}
	callInfo := struct {
		V uint32
	}{
		V: v,
	}
	mock.lockSetPowerManagementLimit.Lock()
	mock.calls.SetPowerManagementLimit = append(mock.calls.SetPowerManagementLimit, callInfo)
	mock.lockSetPowerManagementLimit.Unlock()
	return mock.SetPowerManagementLimitFunc(v)
}

// SetPowerManagementLimitCalls gets all the calls that were made to SetPowerManagementLimit.
// Check the length with:
//
//	len(mockedDevice.SetPowerManagementLimitCalls())
func (mock *Device) SetPowerManagementLimitCalls() []struct {
	V uint32
} {
	var calls []struct {
		V uint32
	}
	mock.lockSetPowerManagementLimit.RLock()
	calls = mock.calls.SetPowerManagementLimit
	mock.lockSetPowerManagementLimit.RUnlock()
	return calls
}

// SetPowerManagementLimit_v2 calls SetPowerManagementLimit_v2Func.
func (mock *Device) SetPowerManagementLimit_v2(powerValue_v2 *nvml.PowerValue_v2) nvml.Return {
	if mock.SetPowerManagementLimit_v2Func == nil {
		panic("Device.SetPowerManagementLimit_v2Func: method is nil but Device.SetPowerManagementLimit_v2 was just called")
	}
	callInfo := struct {
		PowerValue_v2 *nvml.PowerValue_v2
	}{
		PowerValue_v2: powerValue_v2,
	}
	mock.lockSetPowerManagementLimit_v2.Lock()
	mock.calls.SetPowerManagementLimit_v2 = append(mock.calls.SetPowerManagementLimit_v2, callInfo)
	mock.lockSetPowerManagementLimit_v2.Unlock()
	return mock.SetPowerManagementLimit_v2Func(powerValue_v2)
}

// SetPowerManagementLimit_v2Calls gets all the calls that were made to SetPowerManagementLimit_v2.
// Check the length with:
//
//	len(mockedDevice.SetPowerManagementLimit_v2Calls())
func (mock *Device) SetPowerManagementLimit_v2Calls() []struct {
	PowerValue_v2 *nvml.PowerValue_v2
} {
	var calls []struct {
		PowerValue_v2 *nvml.PowerValue_v2
	}
	mock.lockSetPowerManagementLimit_v2.RLock()
	calls = mock.calls.SetPowerManagementLimit_v2
	mock.lockSetPowerManagementLimit_v2.RUnlock()
	return calls
}

// SetTemperatureThreshold calls SetTemperatureThresholdFunc.
func (mock *Device) SetTemperatureThreshold(temperatureThresholds nvml.TemperatureThresholds, n int) nvml.Return {
	if mock.SetTemperatureThresholdFunc == nil {
		panic("Device.SetTemperatureThresholdFunc: method is nil but Device.SetTemperatureThreshold was just called")
	}
	callInfo := struct {
		TemperatureThresholds nvml.TemperatureThresholds
		N                     int
	}{
		TemperatureThresholds: temperatureThresholds,
		N:                     n,
	}
	mock.lockSetTemperatureThreshold.Lock()
	mock.calls.SetTemperatureThreshold = append(mock.calls.SetTemperatureThreshold, callInfo)
	mock.lockSetTemperatureThreshold.Unlock()
	return mock.SetTemperatureThresholdFunc(temperatureThresholds, n)
}

// SetTemperatureThresholdCalls gets all the calls that were made to SetTemperatureThreshold.
// Check the length with:
//
//	len(mockedDevice.SetTemperatureThresholdCalls())
func (mock *Device) SetTemperatureThresholdCalls() []struct {
	TemperatureThresholds nvml.TemperatureThresholds
	N                     int
} {
	var calls []struct {
		TemperatureThresholds nvml.TemperatureThresholds
		N                     int
	}
	mock.lockSetTemperatureThreshold.RLock()
	calls = mock.calls.SetTemperatureThreshold
	mock.lockSetTemperatureThreshold.RUnlock()
	return calls
}

// SetVgpuCapabilities calls SetVgpuCapabilitiesFunc.
func (mock *Device) SetVgpuCapabilities(deviceVgpuCapability nvml.DeviceVgpuCapability, enableState nvml.EnableState) nvml.Return {
	if mock.SetVgpuCapabilitiesFunc == nil {
		panic("Device.SetVgpuCapabilitiesFunc: method is nil but Device.SetVgpuCapabilities was just called")
	}
	callInfo := struct {
		DeviceVgpuCapability nvml.DeviceVgpuCapability
		EnableState          nvml.EnableState
	}{
		DeviceVgpuCapability: deviceVgpuCapability,
		EnableState:          enableState,
	}
	mock.lockSetVgpuCapabilities.Lock()
	mock.calls.SetVgpuCapabilities = append(mock.calls.SetVgpuCapabilities, callInfo)
	mock.lockSetVgpuCapabilities.Unlock()
	return mock.SetVgpuCapabilitiesFunc(deviceVgpuCapability, enableState)
}

// SetVgpuCapabilitiesCalls gets all the calls that were made to SetVgpuCapabilities.
// Check the length with:
//
//	len(mockedDevice.SetVgpuCapabilitiesCalls())
func (mock *Device) SetVgpuCapabilitiesCalls() []struct {
	DeviceVgpuCapability nvml.DeviceVgpuCapability
	EnableState          nvml.EnableState
} {
	var calls []struct {
		DeviceVgpuCapability nvml.DeviceVgpuCapability
		EnableState          nvml.EnableState
	}
	mock.lockSetVgpuCapabilities.RLock()
	calls = mock.calls.SetVgpuCapabilities
	mock.lockSetVgpuCapabilities.RUnlock()
	return calls
}

// SetVgpuHeterogeneousMode calls SetVgpuHeterogeneousModeFunc.
func (mock *Device) SetVgpuHeterogeneousMode(vgpuHeterogeneousMode nvml.VgpuHeterogeneousMode) nvml.Return {
	if mock.SetVgpuHeterogeneousModeFunc == nil {
		panic("Device.SetVgpuHeterogeneousModeFunc: method is nil but Device.SetVgpuHeterogeneousMode was just called")
	}
	callInfo := struct {
		VgpuHeterogeneousMode nvml.VgpuHeterogeneousMode
	}{
		VgpuHeterogeneousMode: vgpuHeterogeneousMode,
	}
	mock.lockSetVgpuHeterogeneousMode.Lock()
	mock.calls.SetVgpuHeterogeneousMode = append(mock.calls.SetVgpuHeterogeneousMode, callInfo)
	mock.lockSetVgpuHeterogeneousMode.Unlock()
	return mock.SetVgpuHeterogeneousModeFunc(vgpuHeterogeneousMode)
}

// SetVgpuHeterogeneousModeCalls gets all the calls that were made to SetVgpuHeterogeneousMode.
// Check the length with:
//
//	len(mockedDevice.SetVgpuHeterogeneousModeCalls())
func (mock *Device) SetVgpuHeterogeneousModeCalls() []struct {
	VgpuHeterogeneousMode nvml.VgpuHeterogeneousMode
} {
	var calls []struct {
		VgpuHeterogeneousMode nvml.VgpuHeterogeneousMode
	}
	mock.lockSetVgpuHeterogeneousMode.RLock()
	calls = mock.calls.SetVgpuHeterogeneousMode
	mock.lockSetVgpuHeterogeneousMode.RUnlock()
	return calls
}

// SetVgpuSchedulerState calls SetVgpuSchedulerStateFunc.
func (mock *Device) SetVgpuSchedulerState(vgpuSchedulerSetState *nvml.VgpuSchedulerSetState) nvml.Return {
	if mock.SetVgpuSchedulerStateFunc == nil {
		panic("Device.SetVgpuSchedulerStateFunc: method is nil but Device.SetVgpuSchedulerState was just called")
	}
	callInfo := struct {
		VgpuSchedulerSetState *nvml.VgpuSchedulerSetState
	}{
		VgpuSchedulerSetState: vgpuSchedulerSetState,
	}
	mock.lockSetVgpuSchedulerState.Lock()
	mock.calls.SetVgpuSchedulerState = append(mock.calls.SetVgpuSchedulerState, callInfo)
	mock.lockSetVgpuSchedulerState.Unlock()
	return mock.SetVgpuSchedulerStateFunc(vgpuSchedulerSetState)
}

// SetVgpuSchedulerStateCalls gets all the calls that were made to SetVgpuSchedulerState.
// Check the length with:
//
//	len(mockedDevice.SetVgpuSchedulerStateCalls())
func (mock *Device) SetVgpuSchedulerStateCalls() []struct {
	VgpuSchedulerSetState *nvml.VgpuSchedulerSetState
} {
	var calls []struct {
		VgpuSchedulerSetState *nvml.VgpuSchedulerSetState
	}
	mock.lockSetVgpuSchedulerState.RLock()
	calls = mock.calls.SetVgpuSchedulerState
	mock.lockSetVgpuSchedulerState.RUnlock()
	return calls
}

// SetVirtualizationMode calls SetVirtualizationModeFunc.
func (mock *Device) SetVirtualizationMode(gpuVirtualizationMode nvml.GpuVirtualizationMode) nvml.Return {
	if mock.SetVirtualizationModeFunc == nil {
		panic("Device.SetVirtualizationModeFunc: method is nil but Device.SetVirtualizationMode was just called")
	}
	callInfo := struct {
		GpuVirtualizationMode nvml.GpuVirtualizationMode
	}{
		GpuVirtualizationMode: gpuVirtualizationMode,
	}
	mock.lockSetVirtualizationMode.Lock()
	mock.calls.SetVirtualizationMode = append(mock.calls.SetVirtualizationMode, callInfo)
	mock.lockSetVirtualizationMode.Unlock()
	return mock.SetVirtualizationModeFunc(gpuVirtualizationMode)
}

// SetVirtualizationModeCalls gets all the calls that were made to SetVirtualizationMode.
// Check the length with:
//
//	len(mockedDevice.SetVirtualizationModeCalls())
func (mock *Device) SetVirtualizationModeCalls() []struct {
	GpuVirtualizationMode nvml.GpuVirtualizationMode
} {
	var calls []struct {
		GpuVirtualizationMode nvml.GpuVirtualizationMode
	}
	mock.lockSetVirtualizationMode.RLock()
	calls = mock.calls.SetVirtualizationMode
	mock.lockSetVirtualizationMode.RUnlock()
	return calls
}

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

// ValidateInforomCalls gets all the calls that were made to ValidateInforom.
// Check the length with:
//
//	len(mockedDevice.ValidateInforomCalls())
func (mock *Device) ValidateInforomCalls() []struct {
} {
	var calls []struct {
	}
	mock.lockValidateInforom.RLock()
	calls = mock.calls.ValidateInforom
	mock.lockValidateInforom.RUnlock()
	return calls
}

// VgpuTypeGetMaxInstances calls VgpuTypeGetMaxInstancesFunc.
func (mock *Device) VgpuTypeGetMaxInstances(vgpuTypeId nvml.VgpuTypeId) (int, nvml.Return) {
	if mock.VgpuTypeGetMaxInstancesFunc == nil {
		panic("Device.VgpuTypeGetMaxInstancesFunc: method is nil but Device.VgpuTypeGetMaxInstances was just called")
	}
	callInfo := struct {
		VgpuTypeId nvml.VgpuTypeId
	}{
		VgpuTypeId: vgpuTypeId,
	}
	mock.lockVgpuTypeGetMaxInstances.Lock()
	mock.calls.VgpuTypeGetMaxInstances = append(mock.calls.VgpuTypeGetMaxInstances, callInfo)
	mock.lockVgpuTypeGetMaxInstances.Unlock()
	return mock.VgpuTypeGetMaxInstancesFunc(vgpuTypeId)
}

// VgpuTypeGetMaxInstancesCalls gets all the calls that were made to VgpuTypeGetMaxInstances.
// Check the length with:
//
//	len(mockedDevice.VgpuTypeGetMaxInstancesCalls())
func (mock *Device) VgpuTypeGetMaxInstancesCalls() []struct {
	VgpuTypeId nvml.VgpuTypeId
} {
	var calls []struct {
		VgpuTypeId nvml.VgpuTypeId
	}
	mock.lockVgpuTypeGetMaxInstances.RLock()
	calls = mock.calls.VgpuTypeGetMaxInstances
	mock.lockVgpuTypeGetMaxInstances.RUnlock()
	return calls
}

// WorkloadPowerProfileClearRequestedProfiles calls WorkloadPowerProfileClearRequestedProfilesFunc.
func (mock *Device) WorkloadPowerProfileClearRequestedProfiles(workloadPowerProfileRequestedProfiles *nvml.WorkloadPowerProfileRequestedProfiles) nvml.Return {
	if mock.WorkloadPowerProfileClearRequestedProfilesFunc == nil {
		panic("Device.WorkloadPowerProfileClearRequestedProfilesFunc: method is nil but Device.WorkloadPowerProfileClearRequestedProfiles was just called")
	}
	callInfo := struct {
		WorkloadPowerProfileRequestedProfiles *nvml.WorkloadPowerProfileRequestedProfiles
	}{
		WorkloadPowerProfileRequestedProfiles: workloadPowerProfileRequestedProfiles,
	}
	mock.lockWorkloadPowerProfileClearRequestedProfiles.Lock()
	mock.calls.WorkloadPowerProfileClearRequestedProfiles = append(mock.calls.WorkloadPowerProfileClearRequestedProfiles, callInfo)
	mock.lockWorkloadPowerProfileClearRequestedProfiles.Unlock()
	return mock.WorkloadPowerProfileClearRequestedProfilesFunc(workloadPowerProfileRequestedProfiles)
}

// WorkloadPowerProfileClearRequestedProfilesCalls gets all the calls that were made to WorkloadPowerProfileClearRequestedProfiles.
// Check the length with:
//
//	len(mockedDevice.WorkloadPowerProfileClearRequestedProfilesCalls())
func (mock *Device) WorkloadPowerProfileClearRequestedProfilesCalls() []struct {
	WorkloadPowerProfileRequestedProfiles *nvml.WorkloadPowerProfileRequestedProfiles
} {
	var calls []struct {
		WorkloadPowerProfileRequestedProfiles *nvml.WorkloadPowerProfileRequestedProfiles
	}
	mock.lockWorkloadPowerProfileClearRequestedProfiles.RLock()
	calls = mock.calls.WorkloadPowerProfileClearRequestedProfiles
	mock.lockWorkloadPowerProfileClearRequestedProfiles.RUnlock()
	return calls
}

// WorkloadPowerProfileGetCurrentProfiles calls WorkloadPowerProfileGetCurrentProfilesFunc.
func (mock *Device) WorkloadPowerProfileGetCurrentProfiles() (nvml.WorkloadPowerProfileCurrentProfiles, nvml.Return) {
	if mock.WorkloadPowerProfileGetCurrentProfilesFunc == nil {
		panic("Device.WorkloadPowerProfileGetCurrentProfilesFunc: method is nil but Device.WorkloadPowerProfileGetCurrentProfiles was just called")
	}
	callInfo := struct {
	}{}
	mock.lockWorkloadPowerProfileGetCurrentProfiles.Lock()
	mock.calls.WorkloadPowerProfileGetCurrentProfiles = append(mock.calls.WorkloadPowerProfileGetCurrentProfiles, callInfo)
	mock.lockWorkloadPowerProfileGetCurrentProfiles.Unlock()
	return mock.WorkloadPowerProfileGetCurrentProfilesFunc()
}

// WorkloadPowerProfileGetCurrentProfilesCalls gets all the calls that were made to WorkloadPowerProfileGetCurrentProfiles.
// Check the length with:
//
//	len(mockedDevice.WorkloadPowerProfileGetCurrentProfilesCalls())
func (mock *Device) WorkloadPowerProfileGetCurrentProfilesCalls() []struct {
} {
	var calls []struct {
	}
	mock.lockWorkloadPowerProfileGetCurrentProfiles.RLock()
	calls = mock.calls.WorkloadPowerProfileGetCurrentProfiles
	mock.lockWorkloadPowerProfileGetCurrentProfiles.RUnlock()
	return calls
}

// WorkloadPowerProfileGetProfilesInfo calls WorkloadPowerProfileGetProfilesInfoFunc.
func (mock *Device) WorkloadPowerProfileGetProfilesInfo() (nvml.WorkloadPowerProfileProfilesInfo, nvml.Return) {
	if mock.WorkloadPowerProfileGetProfilesInfoFunc == nil {
		panic("Device.WorkloadPowerProfileGetProfilesInfoFunc: method is nil but Device.WorkloadPowerProfileGetProfilesInfo was just called")
	}
	callInfo := struct {
	}{}
	mock.lockWorkloadPowerProfileGetProfilesInfo.Lock()
	mock.calls.WorkloadPowerProfileGetProfilesInfo = append(mock.calls.WorkloadPowerProfileGetProfilesInfo, callInfo)
	mock.lockWorkloadPowerProfileGetProfilesInfo.Unlock()
	return mock.WorkloadPowerProfileGetProfilesInfoFunc()
}

// WorkloadPowerProfileGetProfilesInfoCalls gets all the calls that were made to WorkloadPowerProfileGetProfilesInfo.
// Check the length with:
//
//	len(mockedDevice.WorkloadPowerProfileGetProfilesInfoCalls())
func (mock *Device) WorkloadPowerProfileGetProfilesInfoCalls() []struct {
} {
	var calls []struct {
	}
	mock.lockWorkloadPowerProfileGetProfilesInfo.RLock()
	calls = mock.calls.WorkloadPowerProfileGetProfilesInfo
	mock.lockWorkloadPowerProfileGetProfilesInfo.RUnlock()
	return calls
}

// WorkloadPowerProfileSetRequestedProfiles calls WorkloadPowerProfileSetRequestedProfilesFunc.
func (mock *Device) WorkloadPowerProfileSetRequestedProfiles(workloadPowerProfileRequestedProfiles *nvml.WorkloadPowerProfileRequestedProfiles) nvml.Return {
	if mock.WorkloadPowerProfileSetRequestedProfilesFunc == nil {
		panic("Device.WorkloadPowerProfileSetRequestedProfilesFunc: method is nil but Device.WorkloadPowerProfileSetRequestedProfiles was just called")
	}
	callInfo := struct {
		WorkloadPowerProfileRequestedProfiles *nvml.WorkloadPowerProfileRequestedProfiles
	}{
		WorkloadPowerProfileRequestedProfiles: workloadPowerProfileRequestedProfiles,
	}
	mock.lockWorkloadPowerProfileSetRequestedProfiles.Lock()
	mock.calls.WorkloadPowerProfileSetRequestedProfiles = append(mock.calls.WorkloadPowerProfileSetRequestedProfiles, callInfo)
	mock.lockWorkloadPowerProfileSetRequestedProfiles.Unlock()
	return mock.WorkloadPowerProfileSetRequestedProfilesFunc(workloadPowerProfileRequestedProfiles)
}

// WorkloadPowerProfileSetRequestedProfilesCalls gets all the calls that were made to WorkloadPowerProfileSetRequestedProfiles.
// Check the length with:
//
//	len(mockedDevice.WorkloadPowerProfileSetRequestedProfilesCalls())
func (mock *Device) WorkloadPowerProfileSetRequestedProfilesCalls() []struct {
	WorkloadPowerProfileRequestedProfiles *nvml.WorkloadPowerProfileRequestedProfiles
} {
	var calls []struct {
		WorkloadPowerProfileRequestedProfiles *nvml.WorkloadPowerProfileRequestedProfiles
	}
	mock.lockWorkloadPowerProfileSetRequestedProfiles.RLock()
	calls = mock.calls.WorkloadPowerProfileSetRequestedProfiles
	mock.lockWorkloadPowerProfileSetRequestedProfiles.RUnlock()
	return calls
}
