// 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{
//			CcuGetStreamStateFunc: func() (int, nvml.Return) {
//				panic("mock out the CcuGetStreamState method")
//			},
//			CcuSetStreamStateFunc: func(n int) nvml.Return {
//				panic("mock out the CcuSetStreamState method")
//			},
//			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")
//			},
//			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")
//			},
//			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")
//			},
//			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")
//			},
//			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")
//			},
//			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")
//			},
//			GetDriverModelFunc: func() (nvml.DriverModel, nvml.DriverModel, nvml.Return) {
//				panic("mock out the GetDriverModel 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")
//			},
//			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")
//			},
//			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")
//			},
//			GetGpuInstanceProfileInfoVFunc: func(n int) nvml.GpuInstanceProfileInfoV {
//				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")
//			},
//			GetMPSComputeRunningProcessesFunc: func() ([]nvml.ProcessInfo, nvml.Return) {
//				panic("mock out the GetMPSComputeRunningProcesses 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")
//			},
//			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")
//			},
//			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")
//			},
//			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")
//			},
//			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")
//			},
//			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")
//			},
//			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")
//			},
//			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")
//			},
//			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")
//			},
//			GetRemappedRowsFunc: func() (int, int, bool, bool, nvml.Return) {
//				panic("mock out the GetRemappedRows 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")
//			},
//			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")
//			},
//			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")
//			},
//			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")
//			},
//			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")
//			},
//			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")
//			},
//			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")
//			},
//			GpmSampleGetFunc: func(gpmSample nvml.GpmSample) nvml.Return {
//				panic("mock out the GpmSampleGet 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")
//			},
//			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")
//			},
//			SetComputeModeFunc: func(computeMode nvml.ComputeMode) nvml.Return {
//				panic("mock out the SetComputeMode 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")
//			},
//			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")
//			},
//			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")
//			},
//			SetTemperatureThresholdFunc: func(temperatureThresholds nvml.TemperatureThresholds, n int) nvml.Return {
//				panic("mock out the SetTemperatureThreshold 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")
//			},
//		}
//
//		// use mockedDevice in code that requires nvml.Device
//		// and then make assertions.
//
//	}
type Device struct {
	// CcuGetStreamStateFunc mocks the CcuGetStreamState method.
	CcuGetStreamStateFunc func() (int, nvml.Return)

	// CcuSetStreamStateFunc mocks the CcuSetStreamState method.
	CcuSetStreamStateFunc func(n int) nvml.Return

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

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

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

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

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

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

	// GetDriverModelFunc mocks the GetDriverModel method.
	GetDriverModelFunc 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)

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

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

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

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

	// GetMPSComputeRunningProcessesFunc mocks the GetMPSComputeRunningProcesses method.
	GetMPSComputeRunningProcessesFunc func() ([]nvml.ProcessInfo, 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)

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

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

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

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

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

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

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

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

	// GetRemappedRowsFunc mocks the GetRemappedRows method.
	GetRemappedRowsFunc func() (int, int, bool, bool, 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)

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

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

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

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

	// GetVgpuProcessUtilizationFunc mocks the GetVgpuProcessUtilization method.
	GetVgpuProcessUtilizationFunc func(v uint64) ([]nvml.VgpuProcessUtilizationSample, 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)

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

	// GpmSampleGetFunc mocks the GpmSampleGet method.
	GpmSampleGetFunc func(gpmSample nvml.GpmSample) 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)

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

	// SetComputeModeFunc mocks the SetComputeMode method.
	SetComputeModeFunc func(computeMode nvml.ComputeMode) 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

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

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

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

	// SetTemperatureThresholdFunc mocks the SetTemperatureThreshold method.
	SetTemperatureThresholdFunc func(temperatureThresholds nvml.TemperatureThresholds, n int) 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)

	// calls tracks calls to the methods.
	calls struct {
		// CcuGetStreamState holds details about calls to the CcuGetStreamState method.
		CcuGetStreamState []struct {
		}
		// CcuSetStreamState holds details about calls to the CcuSetStreamState method.
		CcuSetStreamState []struct {
			// N is the n argument value.
			N int
		}
		// 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 {
		}
		// 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 {
		}
		// 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
		}
		// 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 {
		}
		// 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 {
		}
		// 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 {
		}
		// GetDriverModel holds details about calls to the GetDriverModel method.
		GetDriverModel []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 {
		}
		// 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 {
		}
		// 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
		}
		// 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 {
		}
		// GetMPSComputeRunningProcesses holds details about calls to the GetMPSComputeRunningProcesses method.
		GetMPSComputeRunningProcesses []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 {
		}
		// 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 {
		}
		// 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
		}
		// 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
		}
		// 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 {
		}
		// 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
		}
		// 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 {
		}
		// 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 {
		}
		// 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
		}
		// GetRemappedRows holds details about calls to the GetRemappedRows method.
		GetRemappedRows []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 {
		}
		// 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 {
		}
		// 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
		}
		// 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
		}
		// 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
		}
		// 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 {
		}
		// 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 {
		}
		// GpmSampleGet holds details about calls to the GpmSampleGet method.
		GpmSampleGet []struct {
			// GpmSample is the gpmSample argument value.
			GpmSample nvml.GpmSample
		}
		// 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
		}
		// 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
		}
		// SetComputeMode holds details about calls to the SetComputeMode method.
		SetComputeMode []struct {
			// ComputeMode is the computeMode argument value.
			ComputeMode nvml.ComputeMode
		}
		// 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
		}
		// 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
		}
		// 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
		}
		// 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
		}
		// 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
		}
	}
	lockCcuGetStreamState                  sync.RWMutex
	lockCcuSetStreamState                  sync.RWMutex
	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
	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
	lockGetClkMonStatus                    sync.RWMutex
	lockGetClock                           sync.RWMutex
	lockGetClockInfo                       sync.RWMutex
	lockGetComputeInstanceId               sync.RWMutex
	lockGetComputeMode                     sync.RWMutex
	lockGetComputeRunningProcesses         sync.RWMutex
	lockGetCpuAffinity                     sync.RWMutex
	lockGetCpuAffinityWithinScope          sync.RWMutex
	lockGetCreatableVgpus                  sync.RWMutex
	lockGetCudaComputeCapability           sync.RWMutex
	lockGetCurrPcieLinkGeneration          sync.RWMutex
	lockGetCurrPcieLinkWidth               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
	lockGetDriverModel                     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
	lockGetFanSpeed_v2                     sync.RWMutex
	lockGetFieldValues                     sync.RWMutex
	lockGetGpcClkMinMaxVfOffset            sync.RWMutex
	lockGetGpcClkVfOffset                  sync.RWMutex
	lockGetGpuFabricInfo                   sync.RWMutex
	lockGetGpuInstanceById                 sync.RWMutex
	lockGetGpuInstanceId                   sync.RWMutex
	lockGetGpuInstancePossiblePlacements   sync.RWMutex
	lockGetGpuInstanceProfileInfo          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
	lockGetMPSComputeRunningProcesses      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
	lockGetMultiGpuBoard                   sync.RWMutex
	lockGetName                            sync.RWMutex
	lockGetNumFans                         sync.RWMutex
	lockGetNumGpuCores                     sync.RWMutex
	lockGetNvLinkCapability                sync.RWMutex
	lockGetNvLinkErrorCounter              sync.RWMutex
	lockGetNvLinkRemoteDeviceType          sync.RWMutex
	lockGetNvLinkRemotePciInfo             sync.RWMutex
	lockGetNvLinkState                     sync.RWMutex
	lockGetNvLinkUtilizationControl        sync.RWMutex
	lockGetNvLinkUtilizationCounter        sync.RWMutex
	lockGetNvLinkVersion                   sync.RWMutex
	lockGetP2PStatus                       sync.RWMutex
	lockGetPciInfo                         sync.RWMutex
	lockGetPcieLinkMaxSpeed                sync.RWMutex
	lockGetPcieReplayCounter               sync.RWMutex
	lockGetPcieSpeed                       sync.RWMutex
	lockGetPcieThroughput                  sync.RWMutex
	lockGetPerformanceState                sync.RWMutex
	lockGetPersistenceMode                 sync.RWMutex
	lockGetPgpuMetadataString              sync.RWMutex
	lockGetPowerManagementDefaultLimit     sync.RWMutex
	lockGetPowerManagementLimit            sync.RWMutex
	lockGetPowerManagementLimitConstraints sync.RWMutex
	lockGetPowerManagementMode             sync.RWMutex
	lockGetPowerSource                     sync.RWMutex
	lockGetPowerState                      sync.RWMutex
	lockGetPowerUsage                      sync.RWMutex
	lockGetProcessUtilization              sync.RWMutex
	lockGetRemappedRows                    sync.RWMutex
	lockGetRetiredPages                    sync.RWMutex
	lockGetRetiredPagesPendingStatus       sync.RWMutex
	lockGetRetiredPages_v2                 sync.RWMutex
	lockGetRowRemapperHistogram            sync.RWMutex
	lockGetSamples                         sync.RWMutex
	lockGetSerial                          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
	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
	lockGetVgpuMetadata                    sync.RWMutex
	lockGetVgpuProcessUtilization          sync.RWMutex
	lockGetVgpuSchedulerCapabilities       sync.RWMutex
	lockGetVgpuSchedulerLog                sync.RWMutex
	lockGetVgpuSchedulerState              sync.RWMutex
	lockGetVgpuUtilization                 sync.RWMutex
	lockGetViolationStatus                 sync.RWMutex
	lockGetVirtualizationMode              sync.RWMutex
	lockGpmMigSampleGet                    sync.RWMutex
	lockGpmQueryDeviceSupport              sync.RWMutex
	lockGpmQueryDeviceSupportV             sync.RWMutex
	lockGpmSampleGet                       sync.RWMutex
	lockIsMigDeviceHandle                  sync.RWMutex
	lockOnSameBoard                        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
	lockSetComputeMode                     sync.RWMutex
	lockSetCpuAffinity                     sync.RWMutex
	lockSetDefaultAutoBoostedClocksEnabled sync.RWMutex
	lockSetDefaultFanSpeed_v2              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
	lockSetPersistenceMode                 sync.RWMutex
	lockSetPowerManagementLimit            sync.RWMutex
	lockSetTemperatureThreshold            sync.RWMutex
	lockSetVgpuSchedulerState              sync.RWMutex
	lockSetVirtualizationMode              sync.RWMutex
	lockValidateInforom                    sync.RWMutex
	lockVgpuTypeGetMaxInstances            sync.RWMutex
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

// GetGpuInstanceProfileInfoV calls GetGpuInstanceProfileInfoVFunc.
func (mock *Device) GetGpuInstanceProfileInfoV(n int) nvml.GpuInstanceProfileInfoV {
	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
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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