proxmox

const (
	Client_Error_Nil            = "client may not be nil"
	Client_Error_NotInitialized = "client not initialized"
	Client_Error_UnableVersion  = "unable to get version"
)

const (
	GroupName_Error_Invalid   string = "" /* 136-byte string literal not displayed */
	GroupName_Error_Empty     string = "variable of type (GroupName) may not be empty"
	GroupName_Error_MaxLength string = "variable of type (GroupName) may not be more tha 1000 characters long"
)

const (
	GuestNameErrorEmpty   = `name cannot be empty`
	GuestNameErrorInvalid = `` /* 153-byte string literal not displayed */
	GuestNameErrorLength  = `name has a maximum length of 128`
	GuestNameErrorStart   = `name cannot start with a hyphen (-) or dot (.)`
	GuestNameErrorEnd     = `name cannot end with a hyphen (-) or dot (.)`
)

const (
	GuestNetworkRate_Error_Invalid = "network rate must be in the range 0 to 10240000"
	GuestNetworkRateMaximum        = 10240000
	GuestNetworkRateUnlimited      = GuestNetworkRate(0)
)

const (
	GuestID_Error_Maximum = "guestID should be less than 1000000000"
	GuestID_Error_Minimum = "guestID should be greater than 99"
	GuestIdMaximum        = 999999999
	GuestIdMinimum        = 100
)

const (
	HaNodeAffinityRule_Error_GuestsEmpty    = "guests must not be empty"
	HaNodeAffinityRule_Error_GuestsRequired = "guests must be specified during creation"
	HaNodeAffinityRule_Error_Kind           = "rule is not a node affinity rule"
	HaNodeAffinityRule_Error_NodesEmpty     = "nodes must not be empty"
	HaNodeAffinityRule_Error_NodesRequired  = "nodes must be specified during creation"
)

const (
	HaResourceAffinityRule_Error_AffinityRequired = "affinity must be specified during creation"
	HaResourceAffinityRule_Error_GuestsEmpty      = "guests must not be empty"
	HaResourceAffinityRule_Error_GuestsRequired   = "guests must be specified during creation"
	HaResourceAffinityRule_Error_Kind             = "rule is not a resource affinity rule"
)

const (
	HaRuleID_Error_MinLength = `ha rule ID must at least be 2 characters`
	HaRuleID_Error_MaxLength = `ha rule ID has a maximum of 128 characters`
	HaRuleID_Error_Invalid   = `ha rule ID did not match the following regex '^[a-zA-Z][a-zA-Z0-9\-_]{2,127}$'`
	HaRuleID_Error_Start     = `ha rule ID can only start with a lower or upper case letter`
	HaRuleIDMin              = 2
	HaRuleIDMax              = 128
)

const (
	HaPriority_Error_Invalid = "priority must be between 0 and 1000"
	HaPriorityMax            = 1000
)

const (
	LxcCpuCoresMaximum        = 8192
	LxcCpuCores_Error_Invalid = "cpu cores should be in the range 0-8192"
)

const (
	LxcCpuLimitMaximum        = 8192
	LxcCpuLimit_Error_Invalid = "cpu limit should be in the range 0-8192"
)

const (
	LxcCpuUnitsDefault        = 0 // uses the PVE default
	LxcCpuUnitsMaximum        = 100000
	LxcCpuUnits_Error_Minimum = "cpu units has a minimum of 8"
	LxcCpuUnits_Error_Maximum = "cpu units has a maximum of 100000"
)

const (
	LxcFeatures_Error_MutuallyExclusive        = "privileged and unprivileged features are mutually exclusive"
	LxcFeatures_Error_PrivilegedInUnprivileged = "privileged features cannot be set in unprivileged containers"
	LxcFeatures_Error_UnprivilegedInPrivileged = "unprivileged features cannot be set in privileged containers"
)

const (
	LxcBootMount_Error_NoSizeDuringCreation    = "size must be set during creation"
	LxcBootMount_Error_NoStorageDuringCreation = "storage must be set during creation"
	LxcBootMount_Error_QuotaNotPrivileged      = "quota can only be set for privileged guest"
)

const (
	LxcBindMountErrorHostPathRequired  = "host path is required for creation"
	LxcBindMountErrorGuestPathRequired = "guest path is required for creation"
)

const (
	LxcDataMountErrorPathRequired      = "path is required for creation"
	LxcDataMountErrorQuotaUnprivileged = "quota can only be set for privileged containers"
	LxcDataMountErrorSizeRequired      = "size is required for creation"
	LxcDataMountErrorStorageRequired   = "storage is required for creation"
)

const (
	LxcHostPathErrorInvalid          = "host path must not be empty"
	LxcHostPathErrorRelative         = "host path must be absolute"
	LxcHostPathErrorInvalidCharacter = "host path must not contain ',' character"
)

const (
	LxcMountPathErrorInvalid          = "mount point path must not be empty"
	LxcMountPathErrorRelative         = "mount point path must be absolute"
	LxcMountPathErrorInvalidCharacter = "mount point path must not contain ',' character"
)

const (
	LxcNetwork_Error_BridgeRequired = "lxc network bridge is required for creation"
	LxcNetwork_Error_NameRequired   = "lxc network name is required for creation"
)

const (
	LxcNetworksAmount               = 16
	LxcNetworks_Error_Amount        = ""
	LxcNetworks_Error_DuplicateName = "lxc network name must be unique across all networks"
)

const (
	LxcNetworkIdMaximum        = 15
	LxcNetworkID_Error_Invalid = "lxc network id must be between 0 and 15"
)

const (
	LxcNetworkName_Error_Invalid       = `lxc network name must match regex: ^(?!\.\.)[a-zA-Z0-9_.-]{2,16}$`
	LxcNetworkName_Error_LengthMinimum = "lxc network name must be at least 2 characters long"
	LxcNetworkName_Error_LengthMaximum = "lxc network name must be at most 16 characters long"
)

const (
	LxcIPv4_Error_MutuallyExclusive        = "lxc IPv4 Manual and DHCP are mutually exclusive"
	LxcIPv4_Error_MutuallyExclusiveAddress = "lxc IPv4 Address and DHCP/Manual are mutually exclusive"
	LxcIPv4_Error_MutuallyExclusiveGateway = "lxc IPv4 Gateway and DHCP/Manual are mutually exclusive"
)

const (
	LxcIPv6_Error_MutuallyExclusive        = "lxc IPv6 DHCP/Manual/SLAAC are mutually exclusive"
	LxcIPv6_Error_MutuallyExclusiveAddress = "lxc IPv6 Address and DHCP/SLAAC/Manual are mutually exclusive"
	LxcIPv6_Error_MutuallyExclusiveGateway = "lxc IPv6 Gateway and DHCP/SLAAC/Manual are mutually exclusive"
)

const (
	ConfigLXC_Error_BootMountMissing     = "boot mount is required during creation"
	ConfigLXC_Error_CreateOptionsMissing = "create options are required during creation"
)

const (
	LxcMemoryMinimum        = 16
	LxcMemory_Error_Minimum = "memory has a minimum of 16"
)

const (
	LxcTemplate_Error_StorageMissing = "storage is required"
	LxcTemplate_Error_FileMissing    = "file is required"
)

const (
	PoolName_Error_Characters        string = "PoolName may only contain the following characters: a-z, A-Z, 0-9, hyphen (-), and underscore (_)"
	PoolName_Error_Empty             string = "PoolName cannot be empty"
	PoolName_Error_Length            string = "PoolName may not be longer than 1024 characters" // proxmox does not seem to have a max length, so we artificially cap it at 1024
	PoolName_Error_NotExists         string = "Pool doesn't exist"
	PoolName_Error_Exists            string = "Pool already exists"
	PoolName_Error_NoGuestsSpecified string = "no guests specified"
)

const (
	ConfigQemu_Error_UnableToUpdateWithoutReboot string = "unable to update vm without rebooting"
	ConfigQemu_Error_CpuRequired                 string = "cpu is required during creation"
	ConfigQemu_Error_MemoryRequired              string = "memory is required during creation"
	ConfigQemu_Error_NodeRequired                string = "node is required during creation"
)

const (
	CloudInitSnippetPath_Error_Empty             = "cloudInitSnippetPath may not be empty"
	CloudInitSnippetPath_Error_InvalidCharacters = "cloudInitSnippetPath may ony contain the following characters: [a-zA-Z0-9_ -/.]"
	CloudInitSnippetPath_Error_InvalidPath       = "cloudInitSnippetPath must be a valid unix path"
	CloudInitSnippetPath_Error_MaxLength         = "cloudInitSnippetPath may not be longer than 256 characters"
	CloudInitSnippetPath_Error_Relative          = "cloudInitSnippetPath must be an relative path"
)

const (
	QemuCpuCores_Error_LowerBound string = "minimum value of QemuCpuCores is 1"
	QemuCpuCores_Error_UpperBound string = "maximum value of QemuCpuCores is 128"
)

const (
	QemuCpuSockets_Error_LowerBound string = "minimum value of QemuCpuSockets is 1"
	QemuCpuSockets_Error_UpperBound string = "maximum value of QemuCpuSockets is 4"
)

const (
	Error_IsoFile_File    string = "file may not be empty"
	Error_IsoFile_Storage string = "storage may not be empty"
)

const (
	Error_QemuCloudInitDisk_Storage string = "storage should not be empty"
	Error_QemuCloudInitDisk_OnlyOne string = "only one cloud init disk may exist"
)

const (
	Error_QemuDisk_File              string = "file may not be empty"
	Error_QemuDisk_MutuallyExclusive string = "settings cdrom,cloudinit,disk,passthrough are mutually exclusive"
	Error_QemuDisk_Storage           string = "storage may not be empty"
)

const (
	Error_QemuDiskSerial_IllegalCharacter string = "serial may only contain the following characters: abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ1234567890-_"
	Error_QemuDiskSerial_IllegalLength    string = "serial may only be 60 characters long"
)

const (
	QemuGuestAgentType_Isa           QemuGuestAgentType = "isa"
	QemuGuestAgentType_VirtIO        QemuGuestAgentType = "virtio"
	QemuGuestAgentType_None          QemuGuestAgentType = "" // Used to unset the value. Proxmox enforces the default.
	QemuGuestAgentType_Error_Invalid string             = `invalid qemu guest agent type, should one of [` + string(QemuGuestAgentType_Isa) + `, ` + string(QemuGuestAgentType_VirtIO) + `, ""]`
)

const (
	QemuMemory_Error_MinimumCapacityMiB_GreaterThan_CapacityMiB string = "minimum capacity MiB cannot be greater than capacity MiB"
	QemuMemory_Error_NoMemoryCapacity                           string = "no memory capacity specified"
	QemuMemory_Error_SharesHasNoEffectWithoutBallooning         string = "shares has no effect when capacity equals minimum capacity"
)

const (
	QemuMemoryCapacity_Error_Maximum string = "memory capacity has a maximum of 4178944"
	QemuMemoryCapacity_Error_Minimum string = "memory capacity has a minimum of 1"
)

const (
	QemuNetworkInterface_Error_BridgeRequired string = "bridge is required during creation"
	QemuNetworkInterface_Error_ModelRequired  string = "model is required during creation"
	QemuNetworkInterface_Error_MtuNoEffect    string = "mtu has no effect when model is not virtio"
)

const (
	QemuNetworkInterfaceID_Error_Invalid string = "network interface ID must be in the range 0-31"

	QemuNetworkInterfaceID0  QemuNetworkInterfaceID = 0
	QemuNetworkInterfaceID1  QemuNetworkInterfaceID = 1
	QemuNetworkInterfaceID2  QemuNetworkInterfaceID = 2
	QemuNetworkInterfaceID3  QemuNetworkInterfaceID = 3
	QemuNetworkInterfaceID4  QemuNetworkInterfaceID = 4
	QemuNetworkInterfaceID5  QemuNetworkInterfaceID = 5
	QemuNetworkInterfaceID6  QemuNetworkInterfaceID = 6
	QemuNetworkInterfaceID7  QemuNetworkInterfaceID = 7
	QemuNetworkInterfaceID8  QemuNetworkInterfaceID = 8
	QemuNetworkInterfaceID9  QemuNetworkInterfaceID = 9
	QemuNetworkInterfaceID10 QemuNetworkInterfaceID = 10
	QemuNetworkInterfaceID11 QemuNetworkInterfaceID = 11
	QemuNetworkInterfaceID12 QemuNetworkInterfaceID = 12
	QemuNetworkInterfaceID13 QemuNetworkInterfaceID = 13
	QemuNetworkInterfaceID14 QemuNetworkInterfaceID = 14
	QemuNetworkInterfaceID15 QemuNetworkInterfaceID = 15
	QemuNetworkInterfaceID16 QemuNetworkInterfaceID = 16
	QemuNetworkInterfaceID17 QemuNetworkInterfaceID = 17
	QemuNetworkInterfaceID18 QemuNetworkInterfaceID = 18
	QemuNetworkInterfaceID19 QemuNetworkInterfaceID = 19
	QemuNetworkInterfaceID20 QemuNetworkInterfaceID = 20
	QemuNetworkInterfaceID21 QemuNetworkInterfaceID = 21
	QemuNetworkInterfaceID22 QemuNetworkInterfaceID = 22
	QemuNetworkInterfaceID23 QemuNetworkInterfaceID = 23
	QemuNetworkInterfaceID24 QemuNetworkInterfaceID = 24
	QemuNetworkInterfaceID25 QemuNetworkInterfaceID = 25
	QemuNetworkInterfaceID26 QemuNetworkInterfaceID = 26
	QemuNetworkInterfaceID27 QemuNetworkInterfaceID = 27
	QemuNetworkInterfaceID28 QemuNetworkInterfaceID = 28
	QemuNetworkInterfaceID29 QemuNetworkInterfaceID = 29
	QemuNetworkInterfaceID30 QemuNetworkInterfaceID = 30
	QemuNetworkInterfaceID31 QemuNetworkInterfaceID = 31

	QemuNetworkInterfaceIDMaximum QemuNetworkInterfaceID = QemuNetworkInterfaceID31
)

const (
	QemuNetworkQueueMaximum        QemuNetworkQueue = 64
	QemuNetworkQueue_Error_Invalid string           = "network queue must be in the range 0-64"
)

const (
	QemuPciID_Error_Invalid string = "pci id must be in the range 0-15"

	QemuPciIDMaximum = QemuPciID15

	QemuPciID0  QemuPciID = 0
	QemuPciID1  QemuPciID = 1
	QemuPciID2  QemuPciID = 2
	QemuPciID3  QemuPciID = 3
	QemuPciID4  QemuPciID = 4
	QemuPciID5  QemuPciID = 5
	QemuPciID6  QemuPciID = 6
	QemuPciID7  QemuPciID = 7
	QemuPciID8  QemuPciID = 8
	QemuPciID9  QemuPciID = 9
	QemuPciID10 QemuPciID = 10
	QemuPciID11 QemuPciID = 11
	QemuPciID12 QemuPciID = 12
	QemuPciID13 QemuPciID = 13
	QemuPciID14 QemuPciID = 14
	QemuPciID15 QemuPciID = 15
)

const (
	PciID_Error_InvalidBus      string = "pci id invalid bus identifier"
	PciID_Error_InvalidDomain   string = "pci id invalid domain identifier"
	PciID_Error_LengthBus       string = "pci id bus identifier should be 2 characters long"
	PciID_Error_LengthDomain    string = "pci id domain identifier should be 4 characters long"
	PciID_Error_MissingBus      string = "pci id missing bus identifier"
	PciID_Error_MissingDevice   string = "pci id missing device identifier"
	PciID_Error_LengthDevice    string = "pci id device identifier should be 2 characters long"
	PciID_Error_InvalidDevice   string = "pci id invalid device identifier"
	PciID_Error_InvalidFunction string = "pci id invalid function identifier"
	PciID_Error_MaximumFunction string = "pci id function identifier should be in the range 0-7"
)

const (
	EntropySourceRawRandom  = "/dev/random"
	EntropySourceRawURandom = "/dev/urandom"
	EntropySourceRawHwRNG   = "/dev/hwrng"
)

const (
	SerialID0               SerialID = 0
	SerialID1               SerialID = 1
	SerialID2               SerialID = 2
	SerialID3               SerialID = 3
	SerialID_Errors_Invalid string   = "serial id must be one of 0,1,2,3"
)

const (
	SerialInterface_Errors_MutualExclusive string = "path and socket are mutually exclusive"
	SerialInterface_Errors_Empty           string = "path or socket must be set"
)

const (
	TpmVersion_1_2           TpmVersion = "v1.2"
	TpmVersion_2_0           TpmVersion = "v2.0"
	TpmVersion_Error_Invalid string     = "enum TmpVersion should be one of: " + string(TpmVersion_1_2) + ", " + string(TpmVersion_2_0)
)

const (
	QemuUsbID_Error_Invalid string = "usb id must be in the range 0-4"

	QemuUsbIDMaximum = QemuUsbID4

	QemuUsbID0 QemuUsbID = 0
	QemuUsbID1 QemuUsbID = 1
	QemuUsbID2 QemuUsbID = 2
	QemuUsbID3 QemuUsbID = 3
	QemuUsbID4 QemuUsbID = 4
)

const (
	QemuUSB_Error_MutualExclusive string = "usb device, usb mapped, usb port, and usb spice are mutually exclusive"
	QemuUSB_Error_DeviceID        string = "usb device id is required during creation"
	QemuUSB_Error_MappingID       string = "usb mapping id is required during creation"
	QemuUSB_Error_PortID          string = "usb port id is required during creation"
)

const (
	UsbDeviceID_Error_Invalid   string = "invalid usb device-id"
	UsbDeviceID_Error_VendorID  string = "usb vendor-id isn't valid hexadecimal"
	UsbDeviceID_Error_ProductID string = "usb product-id isn't valid hexadecimal"
)

const (
	NodeName_Error_Alphabetical string = "Node name must contain at least one alphabetical character"
	NodeName_Error_Empty        string = "Node name cannot be empty"
	NodeName_Error_HyphenEnd    string = "Node name cannot end with a hyphen"
	NodeName_Error_HyphenStart  string = "Node name cannot start with a hyphen"
	NodeName_Error_Illegal      string = "Node name may only contain the following characters: abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789-"
	NodeName_Error_Length       string = "Node name must be less than 64 characters"
)

const (
	ResourceMappingUsbID_Error_MaxLength string = resourceMappingUsbKey + mappingID_Error_MaxLength
	ResourceMappingUsbID_Error_MinLength string = resourceMappingUsbKey + mappingID_Error_MinLength
	ResourceMappingUsbID_Error_Start     string = resourceMappingUsbKey + mappingID_Error_Start
	ResourceMappingUsbID_Error_Invalid   string = resourceMappingUsbKey + mappingID_Error_Invalid
)

const (
	ResourceMappingPciID_Error_MaxLength string = resourceMappingPciKey + mappingID_Error_MaxLength
	ResourceMappingPciID_Error_MinLength string = resourceMappingPciKey + mappingID_Error_MinLength
	ResourceMappingPciID_Error_Start     string = resourceMappingPciKey + mappingID_Error_Start
	ResourceMappingPciID_Error_Invalid   string = resourceMappingPciKey + mappingID_Error_Invalid
)

const (
	SnapshotName_Error_IllegalCharacters string = "SnapshotName must only contain the following characters: abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789-_"
	SnapshotName_Error_MaxLength         string = "SnapshotName must be at most 40 characters long"
	SnapshotName_Error_MinLength         string = "SnapshotName must be at least 3 characters long"
	SnapshotName_Error_StartNoLetter     string = "SnapshotName must start with a letter"
)

const (
	AuthorizedKey_Error_NilPointer = "authorizedKey pointer is nil"
	AuthorizedKey_Error_Invalid    = "invalid value for AuthorizedKey"
)

const (
	Tag_Error_Invalid   string = "" /* 138-byte string literal not displayed */
	Tag_Error_MaxLength string = "tag may only be 124 characters"
	Tag_Error_Empty     string = "tag may not be empty"
)

const (
	TriBoolFalse          TriBool = -1
	TriBoolNone           TriBool = 0
	TriBoolTrue           TriBool = 1
	TriBool_Error_Invalid string  = "invalid value for TriBool"
)

const (
	VlanMaximum        Vlan   = 4095
	Vlan_Error_Invalid string = "vlan tag must be in the range 0-4095"
)

const (
	CloneLxcTarget_Error_MutualExclusivity = clone_Error_MutuallyExclusive
	CloneLxcTarget_Error_NoneSet           = clone_Error_NoneSet
)

const (
	CloneQemuTarget_Error_MutualExclusivity = clone_Error_MutuallyExclusive
	CloneQemuTarget_Error_NoneSet           = clone_Error_NoneSet
)

const CloudInitIPv4Config_Error_DhcpAddressMutuallyExclusive string = "ipv4 dhcp is mutually exclusive with address"

const CloudInitIPv4Config_Error_DhcpGatewayMutuallyExclusive string = "ipv4 dhcp is mutually exclusive with gateway"

const CloudInitIPv6Config_Error_DhcpAddressMutuallyExclusive string = "ipv6 dhcp is mutually exclusive with address"

const CloudInitIPv6Config_Error_DhcpGatewayMutuallyExclusive string = "ipv6 dhcp is mutually exclusive with gateway"

const CloudInitIPv6Config_Error_DhcpSlaacMutuallyExclusive string = "ipv6 dhcp is mutually exclusive with slaac"

const CloudInitIPv6Config_Error_SlaacAddressMutuallyExclusive string = "ipv6 slaac is mutually exclusive with address"

const CloudInitIPv6Config_Error_SlaacGatewayMutuallyExclusive string = "ipv6 slaac is mutually exclusive with gateway"

const CloudInit_Error_UpgradePackagesPre8 = "upgradePackages is only available in version 8 and above"

const CpuLimit_Error_Maximum string = "maximum value of CpuLimit is 128"

const CpuUnits_Error_Maximum string = "maximum value of CpuUnits is 262144"

const (
	ERROR_QemuDiskId_Invalid string = "invalid Disk ID"
)

const (
	EntropySourceErrorInvalid = "invalid value for EntropySource"
)

const Error_NewUserID string = "no username or realm specified, syntax is \"username@realm\""

const (
	Error_QemuCdRom_MutuallyExclusive string = "iso and passthrough are mutually exclusive"
)

const (
	Error_QemuDiskBandwidthIopsLimitBurst string = "burst may not be lower then 10 except for 0"
)

const (
	Error_QemuDiskBandwidthIopsLimitConcurrent string = "concurrent may not be lower then 10 except for 0"
)

const (
	Error_QemuDiskBandwidthMBpsLimitBurst string = "burst may not be lower then 1 except for 0"
)

const (
	Error_QemuDiskBandwidthMBpsLimitConcurrent string = "concurrent may not be lower then 1 except for 0"
)

const Error_QemuWorldWideName_Invalid string = "world wide name should be prefixed with 0x followed by 8 hexadecimal values"

const GuestType_Error_Invalid = "guest type should be one of (lxc, qemu)"

const HaAffinity_Error_Invalid = "affinity must be either positive or negative"

const HaRule_Error_VersionTooLow = "HA rules require Proxmox VE 9.0 or higher"

const IPv4Address_Error_Invalid = "ipv4Address is not a valid ipv4 address"

const IPv4CIDR_Error_Invalid = "ipv4CIDR is not a valid ipv4 address"

const IPv6Address_Error_Invalid = "ipv6Address is not a valid ipv6 address"

const IPv6CIDR_Error_Invalid = "ipv6CIDR is not a valid ipv6 address"

const (
	LxcCreateOptions_Error_TemplateMissing = "os template is required during creation"
)

const LxcMountErrorMutuallyExclusive = "bindMount and dataMount are mutually exclusive"

const LxcMountIDMaximum = 255

const (
	LxcMountSizeErrorMinimum = "mount point size must be greater than 131071"
)

const LxcMountsAmount = 256

const (
	MTU_Error_Invalid = "mtu must be in the range 576-65520"
)

const PciDeviceID_Error_Invalid string = "device id" + qemuPci_Error_Maximum

const (
	PciMediatedDevice_Error_Invalid string = "mediated device may not include " + pciMediatedDevice_Filter
)

const PciSubDeviceID_Error_Invalid string = "sub device id" + qemuPci_Error_Maximum

const PciSubVendorID_Error_Invalid string = "sub vendor id" + qemuPci_Error_Maximum

const PciVendorID_Error_Invalid string = "vendor id" + qemuPci_Error_Maximum

const (
	PermissionErrorPrefix string = "permission error:" // Check if an error starts with this to see if it's a permission error.
)

const (
	QemuCPU_Error_CoresRequired string = "cores is required"
)

const (
	QemuDiskSize_Error_Minimum string = "disk size must be greater then 4096"
)

const QemuMTU_Error_Invalid string = "inherit and value are mutually exclusive"

const (
	QemuMemoryBalloonCapacity_Error_Invalid string = "memory balloon capacity has a maximum of 4178944"
)

const (
	QemuMemoryShares_Error_Invalid string = "memory shares has a maximum of 50000"
)

const QemuNetworkInterfacesAmount = uint8(QemuNetworkInterfaceIDMaximum) + 1

const QemuPciDevicesAmount = uint8(QemuPciIDMaximum) + 1

const QemuPciMapping_Error_RequiredID string = "mapped id is required during creation"

const QemuPciRaw_Error_RequiredID string = "raw id is required during creation"

const QemuPci_Error_MutualExclusive string = "mapping and raw are mutually exclusive"

const QemuUSBsAmount = uint8(QemuUsbIDMaximum) + 1

const SerialPath_Errors_Invalid string = "path must start with /dev/"

const (
	Tags_Error_Duplicate string = "duplicate tag found"
)

const TaskStatusCheckInterval = 2

const TmpState_Error_VersionRequired string = "version is required"

const (
	UsbPortID_Error_Invalid string = "invalid usb port id. Expected expression of the form '<bus>-<port>(.<port>)*' where bus and port are integers"
)

const (
	VirtIoRNGErrorSourceNotSet = "source must be set on creation"
)

const (
	VmRef_Error_IDnotSet = "vm reference id not set"
)

const (
	VmRef_Error_Nil string = "vm reference may not be nil"
)