/*
 * winerror.d
 *
 * This module binds WinError.h to D. The original copyright notice
 * is preserved below.
 *
 * Author: Dave Wilkinson
 * Originated: November 25th, 2009
 *
 */

module binding.win32.winerror;

/************************************************************************
*                                                                       *
*   winerror.h --  error code definitions for the Win32 API functions   *
*                                                                       *
*   Copyright (c) Microsoft Corp.  All rights reserved.                 *
*                                                                       *
************************************************************************/


//
//  Values are 32 bit values laid out as follows:
//
//   3 3 2 2 2 2 2 2 2 2 2 2 1 1 1 1 1 1 1 1 1 1
//   1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0
//  +---+-+-+-----------------------+-------------------------------+
//  |Sev|C|R|     Facility          |               Code            |
//  +---+-+-+-----------------------+-------------------------------+
//
//  where
//
//      Sev - is the severity code
//
//          00 - Success
//          01 - Informational
//          10 - Warning
//          11 - Error
//
//      C - is the Customer code flag
//
//      R - is a reserved bit
//
//      Facility - is the facility code
//
//      Code - is the facility's status code
//
//
// Define the facility codes
//
const auto FACILITY_WINRM = 51;
const auto FACILITY_WINDOWSUPDATE = 36;
const auto FACILITY_WINDOWS_DEFENDER = 80;
const auto FACILITY_WINDOWS_CE = 24;
const auto FACILITY_WINDOWS = 8;
const auto FACILITY_URT = 19;
const auto FACILITY_UMI = 22;
const auto FACILITY_TPM_SOFTWARE = 41;
const auto FACILITY_TPM_SERVICES = 40;
const auto FACILITY_SXS = 23;
const auto FACILITY_STORAGE = 3;
const auto FACILITY_STATE_MANAGEMENT = 34;
const auto FACILITY_SSPI = 9;
const auto FACILITY_SCARD = 16;
const auto FACILITY_SHELL = 39;
const auto FACILITY_SETUPAPI = 15;
const auto FACILITY_SECURITY = 9;
const auto FACILITY_RPC = 1;
const auto FACILITY_PLA = 48;
const auto FACILITY_WIN32 = 7;
const auto FACILITY_CONTROL = 10;
const auto FACILITY_NULL = 0;
const auto FACILITY_NDIS = 52;
const auto FACILITY_METADIRECTORY = 35;
const auto FACILITY_MSMQ = 14;
const auto FACILITY_MEDIASERVER = 13;
const auto FACILITY_INTERNET = 12;
const auto FACILITY_ITF = 4;
const auto FACILITY_USERMODE_HYPERVISOR = 53;
const auto FACILITY_HTTP = 25;
const auto FACILITY_GRAPHICS = 38;
const auto FACILITY_FWP = 50;
const auto FACILITY_FVE = 49;
const auto FACILITY_USERMODE_FILTER_MANAGER = 31;
const auto FACILITY_DPLAY = 21;
const auto FACILITY_DISPATCH = 2;
const auto FACILITY_DIRECTORYSERVICE = 37;
const auto FACILITY_CONFIGURATION = 33;
const auto FACILITY_COMPLUS = 17;
const auto FACILITY_USERMODE_COMMONLOG = 26;
const auto FACILITY_CMI = 54;
const auto FACILITY_CERT = 11;
const auto FACILITY_BACKGROUNDCOPY = 32;
const auto FACILITY_ACS = 20;

const auto FACILITY_AAF = 18;

//
// Define the severity codes
//


//
// MessageId: ERROR_SUCCESS
//
// MessageText:
//
// The operation completed successfully.
//

const auto ERROR_SUCCESS = 0;
const auto NO_ERROR = 0;

const auto SEC_E_OK = 0x00000000;
//
// MessageId: ERROR_INVALID_FUNCTION
//
// MessageText:
//
// Incorrect function.
//

const auto ERROR_INVALID_FUNCTION = 1;
//
// MessageId: ERROR_FILE_NOT_FOUND
//
// MessageText:
//
// The system cannot find the file specified.
//

const auto ERROR_FILE_NOT_FOUND = 2;
//
// MessageId: ERROR_PATH_NOT_FOUND
//
// MessageText:
//
// The system cannot find the path specified.
//

const auto ERROR_PATH_NOT_FOUND = 3;
//
// MessageId: ERROR_TOO_MANY_OPEN_FILES
//
// MessageText:
//
// The system cannot open the file.
//

const auto ERROR_TOO_MANY_OPEN_FILES = 4;
//
// MessageId: ERROR_ACCESS_DENIED
//
// MessageText:
//
// Access is denied.
//

const auto ERROR_ACCESS_DENIED = 5;
//
// MessageId: ERROR_INVALID_HANDLE
//
// MessageText:
//
// The handle is invalid.
//

const auto ERROR_INVALID_HANDLE = 6;
//
// MessageId: ERROR_ARENA_TRASHED
//
// MessageText:
//
// The storage control blocks were destroyed.
//

const auto ERROR_ARENA_TRASHED = 7;
//
// MessageId: ERROR_NOT_ENOUGH_MEMORY
//
// MessageText:
//
// Not enough storage is available to process this command.
//

const auto ERROR_NOT_ENOUGH_MEMORY = 8;
//
// MessageId: ERROR_INVALID_BLOCK
//
// MessageText:
//
// The storage control block address is invalid.
//

const auto ERROR_INVALID_BLOCK = 9;
//
// MessageId: ERROR_BAD_ENVIRONMENT
//
// MessageText:
//
// The environment is incorrect.
//

const auto ERROR_BAD_ENVIRONMENT = 10;
//
// MessageId: ERROR_BAD_FORMAT
//
// MessageText:
//
// An attempt was made to load a program with an incorrect format.
//

const auto ERROR_BAD_FORMAT = 11;
//
// MessageId: ERROR_INVALID_ACCESS
//
// MessageText:
//
// The access code is invalid.
//

const auto ERROR_INVALID_ACCESS = 12;
//
// MessageId: ERROR_INVALID_DATA
//
// MessageText:
//
// The data is invalid.
//

const auto ERROR_INVALID_DATA = 13;
//
// MessageId: ERROR_OUTOFMEMORY
//
// MessageText:
//
// Not enough storage is available to complete this operation.
//

const auto ERROR_OUTOFMEMORY = 14;
//
// MessageId: ERROR_INVALID_DRIVE
//
// MessageText:
//
// The system cannot find the drive specified.
//

const auto ERROR_INVALID_DRIVE = 15;
//
// MessageId: ERROR_CURRENT_DIRECTORY
//
// MessageText:
//
// The directory cannot be removed.
//

const auto ERROR_CURRENT_DIRECTORY = 16;
//
// MessageId: ERROR_NOT_SAME_DEVICE
//
// MessageText:
//
// The system cannot move the file to a different disk drive.
//

const auto ERROR_NOT_SAME_DEVICE = 17;
//
// MessageId: ERROR_NO_MORE_FILES
//
// MessageText:
//
// There are no more files.
//

const auto ERROR_NO_MORE_FILES = 18;
//
// MessageId: ERROR_WRITE_PROTECT
//
// MessageText:
//
// The media is write protected.
//

const auto ERROR_WRITE_PROTECT = 19;
//
// MessageId: ERROR_BAD_UNIT
//
// MessageText:
//
// The system cannot find the device specified.
//

const auto ERROR_BAD_UNIT = 20;
//
// MessageId: ERROR_NOT_READY
//
// MessageText:
//
// The device is not ready.
//

const auto ERROR_NOT_READY = 21;
//
// MessageId: ERROR_BAD_COMMAND
//
// MessageText:
//
// The device does not recognize the command.
//

const auto ERROR_BAD_COMMAND = 22;
//
// MessageId: ERROR_CRC
//
// MessageText:
//
// Data error (cyclic redundancy check).
//

const auto ERROR_CRC = 23;
//
// MessageId: ERROR_BAD_LENGTH
//
// MessageText:
//
// The program issued a command but the command length is incorrect.
//

const auto ERROR_BAD_LENGTH = 24;
//
// MessageId: ERROR_SEEK
//
// MessageText:
//
// The drive cannot locate a specific area or track on the disk.
//

const auto ERROR_SEEK = 25;
//
// MessageId: ERROR_NOT_DOS_DISK
//
// MessageText:
//
// The specified disk or diskette cannot be accessed.
//

const auto ERROR_NOT_DOS_DISK = 26;
//
// MessageId: ERROR_SECTOR_NOT_FOUND
//
// MessageText:
//
// The drive cannot find the sector requested.
//

const auto ERROR_SECTOR_NOT_FOUND = 27;
//
// MessageId: ERROR_OUT_OF_PAPER
//
// MessageText:
//
// The printer is out of paper.
//

const auto ERROR_OUT_OF_PAPER = 28;
//
// MessageId: ERROR_WRITE_FAULT
//
// MessageText:
//
// The system cannot write to the specified device.
//

const auto ERROR_WRITE_FAULT = 29;
//
// MessageId: ERROR_READ_FAULT
//
// MessageText:
//
// The system cannot read from the specified device.
//

const auto ERROR_READ_FAULT = 30;
//
// MessageId: ERROR_GEN_FAILURE
//
// MessageText:
//
// A device attached to the system is not functioning.
//

const auto ERROR_GEN_FAILURE = 31;
//
// MessageId: ERROR_SHARING_VIOLATION
//
// MessageText:
//
// The process cannot access the file because it is being used by another process.
//

const auto ERROR_SHARING_VIOLATION = 32;
//
// MessageId: ERROR_LOCK_VIOLATION
//
// MessageText:
//
// The process cannot access the file because another process has locked a portion of the file.
//

const auto ERROR_LOCK_VIOLATION = 33;
//
// MessageId: ERROR_WRONG_DISK
//
// MessageText:
//
// The wrong diskette is in the drive.
// Insert %2 (Volume Serial Number: %3) into drive %1.
//

const auto ERROR_WRONG_DISK = 34;
//
// MessageId: ERROR_SHARING_BUFFER_EXCEEDED
//
// MessageText:
//
// Too many files opened for sharing.
//

const auto ERROR_SHARING_BUFFER_EXCEEDED = 36;
//
// MessageId: ERROR_HANDLE_EOF
//
// MessageText:
//
// Reached the end of the file.
//

const auto ERROR_HANDLE_EOF = 38;
//
// MessageId: ERROR_HANDLE_DISK_FULL
//
// MessageText:
//
// The disk is full.
//

const auto ERROR_HANDLE_DISK_FULL = 39;
//
// MessageId: ERROR_NOT_SUPPORTED
//
// MessageText:
//
// The request is not supported.
//

const auto ERROR_NOT_SUPPORTED = 50;
//
// MessageId: ERROR_REM_NOT_LIST
//
// MessageText:
//
// Windows cannot find the network path. Verify that the network path is correct and the destination computer is not busy or turned off. If Windows still cannot find the network path, contact your network administrator.
//

const auto ERROR_REM_NOT_LIST = 51;
//
// MessageId: ERROR_DUP_NAME
//
// MessageText:
//
// You were not connected because a duplicate name exists on the network. If joining a domain, go to System in Control Panel to change the computer name and try again.  If joining a workgroup, choose another workgroup name.
//

const auto ERROR_DUP_NAME = 52;
//
// MessageId: ERROR_BAD_NETPATH
//
// MessageText:
//
// The network path was not found.
//

const auto ERROR_BAD_NETPATH = 53;
//
// MessageId: ERROR_NETWORK_BUSY
//
// MessageText:
//
// The network is busy.
//

const auto ERROR_NETWORK_BUSY = 54;
//
// MessageId: ERROR_DEV_NOT_EXIST
//
// MessageText:
//
// The specified network resource or device is no longer available.
//

const auto ERROR_DEV_NOT_EXIST = 55;
//
// MessageId: ERROR_TOO_MANY_CMDS
//
// MessageText:
//
// The network BIOS command limit has been reached.
//

const auto ERROR_TOO_MANY_CMDS = 56;
//
// MessageId: ERROR_ADAP_HDW_ERR
//
// MessageText:
//
// A network adapter hardware error occurred.
//

const auto ERROR_ADAP_HDW_ERR = 57;
//
// MessageId: ERROR_BAD_NET_RESP
//
// MessageText:
//
// The specified server cannot perform the requested operation.
//

const auto ERROR_BAD_NET_RESP = 58;
//
// MessageId: ERROR_UNEXP_NET_ERR
//
// MessageText:
//
// An unexpected network error occurred.
//

const auto ERROR_UNEXP_NET_ERR = 59;
//
// MessageId: ERROR_BAD_REM_ADAP
//
// MessageText:
//
// The remote adapter is not compatible.
//

const auto ERROR_BAD_REM_ADAP = 60;
//
// MessageId: ERROR_PRINTQ_FULL
//
// MessageText:
//
// The printer queue is full.
//

const auto ERROR_PRINTQ_FULL = 61;
//
// MessageId: ERROR_NO_SPOOL_SPACE
//
// MessageText:
//
// Space to store the file waiting to be printed is not available on the server.
//

const auto ERROR_NO_SPOOL_SPACE = 62;
//
// MessageId: ERROR_PRINT_CANCELLED
//
// MessageText:
//
// Your file waiting to be printed was deleted.
//

const auto ERROR_PRINT_CANCELLED = 63;
//
// MessageId: ERROR_NETNAME_DELETED
//
// MessageText:
//
// The specified network name is no longer available.
//

const auto ERROR_NETNAME_DELETED = 64;
//
// MessageId: ERROR_NETWORK_ACCESS_DENIED
//
// MessageText:
//
// Network access is denied.
//

const auto ERROR_NETWORK_ACCESS_DENIED = 65;
//
// MessageId: ERROR_BAD_DEV_TYPE
//
// MessageText:
//
// The network resource type is not correct.
//

const auto ERROR_BAD_DEV_TYPE = 66;
//
// MessageId: ERROR_BAD_NET_NAME
//
// MessageText:
//
// The network name cannot be found.
//

const auto ERROR_BAD_NET_NAME = 67;
//
// MessageId: ERROR_TOO_MANY_NAMES
//
// MessageText:
//
// The name limit for the local computer network adapter card was exceeded.
//

const auto ERROR_TOO_MANY_NAMES = 68;
//
// MessageId: ERROR_TOO_MANY_SESS
//
// MessageText:
//
// The network BIOS session limit was exceeded.
//

const auto ERROR_TOO_MANY_SESS = 69;
//
// MessageId: ERROR_SHARING_PAUSED
//
// MessageText:
//
// The remote server has been paused or is in the process of being started.
//

const auto ERROR_SHARING_PAUSED = 70;
//
// MessageId: ERROR_REQ_NOT_ACCEP
//
// MessageText:
//
// No more connections can be made to this remote computer at this time because there are already as many connections as the computer can accept.
//

const auto ERROR_REQ_NOT_ACCEP = 71;
//
// MessageId: ERROR_REDIR_PAUSED
//
// MessageText:
//
// The specified printer or disk device has been paused.
//

const auto ERROR_REDIR_PAUSED = 72;
//
// MessageId: ERROR_FILE_EXISTS
//
// MessageText:
//
// The file exists.
//

const auto ERROR_FILE_EXISTS = 80;
//
// MessageId: ERROR_CANNOT_MAKE
//
// MessageText:
//
// The directory or file cannot be created.
//

const auto ERROR_CANNOT_MAKE = 82;
//
// MessageId: ERROR_FAIL_I24
//
// MessageText:
//
// Fail on INT 24.
//

const auto ERROR_FAIL_I24 = 83;
//
// MessageId: ERROR_OUT_OF_STRUCTURES
//
// MessageText:
//
// Storage to process this request is not available.
//

const auto ERROR_OUT_OF_STRUCTURES = 84;
//
// MessageId: ERROR_ALREADY_ASSIGNED
//
// MessageText:
//
// The local device name is already in use.
//

const auto ERROR_ALREADY_ASSIGNED = 85;
//
// MessageId: ERROR_INVALID_PASSWORD
//
// MessageText:
//
// The specified network password is not correct.
//

const auto ERROR_INVALID_PASSWORD = 86;
//
// MessageId: ERROR_INVALID_PARAMETER
//
// MessageText:
//
// The parameter is incorrect.
//

const auto ERROR_INVALID_PARAMETER = 87;
//
// MessageId: ERROR_NET_WRITE_FAULT
//
// MessageText:
//
// A write fault occurred on the network.
//

const auto ERROR_NET_WRITE_FAULT = 88;
//
// MessageId: ERROR_NO_PROC_SLOTS
//
// MessageText:
//
// The system cannot start another process at this time.
//

const auto ERROR_NO_PROC_SLOTS = 89;
//
// MessageId: ERROR_TOO_MANY_SEMAPHORES
//
// MessageText:
//
// Cannot create another system semaphore.
//

const auto ERROR_TOO_MANY_SEMAPHORES = 100;
//
// MessageId: ERROR_EXCL_SEM_ALREADY_OWNED
//
// MessageText:
//
// The exclusive semaphore is owned by another process.
//

const auto ERROR_EXCL_SEM_ALREADY_OWNED = 101;
//
// MessageId: ERROR_SEM_IS_SET
//
// MessageText:
//
// The semaphore is set and cannot be closed.
//

const auto ERROR_SEM_IS_SET = 102;
//
// MessageId: ERROR_TOO_MANY_SEM_REQUESTS
//
// MessageText:
//
// The semaphore cannot be set again.
//

const auto ERROR_TOO_MANY_SEM_REQUESTS = 103;
//
// MessageId: ERROR_INVALID_AT_INTERRUPT_TIME
//
// MessageText:
//
// Cannot request exclusive semaphores at interrupt time.
//

const auto ERROR_INVALID_AT_INTERRUPT_TIME = 104;
//
// MessageId: ERROR_SEM_OWNER_DIED
//
// MessageText:
//
// The previous ownership of this semaphore has ended.
//

const auto ERROR_SEM_OWNER_DIED = 105;
//
// MessageId: ERROR_SEM_USER_LIMIT
//
// MessageText:
//
// Insert the diskette for drive %1.
//

const auto ERROR_SEM_USER_LIMIT = 106;
//
// MessageId: ERROR_DISK_CHANGE
//
// MessageText:
//
// The program stopped because an alternate diskette was not inserted.
//

const auto ERROR_DISK_CHANGE = 107;
//
// MessageId: ERROR_DRIVE_LOCKED
//
// MessageText:
//
// The disk is in use or locked by another process.
//

const auto ERROR_DRIVE_LOCKED = 108;
//
// MessageId: ERROR_BROKEN_PIPE
//
// MessageText:
//
// The pipe has been ended.
//

const auto ERROR_BROKEN_PIPE = 109;
//
// MessageId: ERROR_OPEN_FAILED
//
// MessageText:
//
// The system cannot open the device or file specified.
//

const auto ERROR_OPEN_FAILED = 110;
//
// MessageId: ERROR_BUFFER_OVERFLOW
//
// MessageText:
//
// The file name is too long.
//

const auto ERROR_BUFFER_OVERFLOW = 111;
//
// MessageId: ERROR_DISK_FULL
//
// MessageText:
//
// There is not enough space on the disk.
//

const auto ERROR_DISK_FULL = 112;
//
// MessageId: ERROR_NO_MORE_SEARCH_HANDLES
//
// MessageText:
//
// No more internal file identifiers available.
//

const auto ERROR_NO_MORE_SEARCH_HANDLES = 113;
//
// MessageId: ERROR_INVALID_TARGET_HANDLE
//
// MessageText:
//
// The target internal file identifier is incorrect.
//

const auto ERROR_INVALID_TARGET_HANDLE = 114;
//
// MessageId: ERROR_INVALID_CATEGORY
//
// MessageText:
//
// The IOCTL call made by the application program is not correct.
//

const auto ERROR_INVALID_CATEGORY = 117;
//
// MessageId: ERROR_INVALID_VERIFY_SWITCH
//
// MessageText:
//
// The verify-on-write switch parameter value is not correct.
//

const auto ERROR_INVALID_VERIFY_SWITCH = 118;
//
// MessageId: ERROR_BAD_DRIVER_LEVEL
//
// MessageText:
//
// The system does not support the command requested.
//

const auto ERROR_BAD_DRIVER_LEVEL = 119;
//
// MessageId: ERROR_CALL_NOT_IMPLEMENTED
//
// MessageText:
//
// This function is not supported on this system.
//

const auto ERROR_CALL_NOT_IMPLEMENTED = 120;
//
// MessageId: ERROR_SEM_TIMEOUT
//
// MessageText:
//
// The semaphore timeout period has expired.
//

const auto ERROR_SEM_TIMEOUT = 121;
//
// MessageId: ERROR_INSUFFICIENT_BUFFER
//
// MessageText:
//
// The data area passed to a system call is too small.
//

const auto ERROR_INSUFFICIENT_BUFFER = 122;
//
// MessageId: ERROR_INVALID_NAME
//
// MessageText:
//
// The filename, directory name, or volume label syntax is incorrect.
//

const auto ERROR_INVALID_NAME = 123;
//
// MessageId: ERROR_INVALID_LEVEL
//
// MessageText:
//
// The system call level is not correct.
//

const auto ERROR_INVALID_LEVEL = 124;
//
// MessageId: ERROR_NO_VOLUME_LABEL
//
// MessageText:
//
// The disk has no volume label.
//

const auto ERROR_NO_VOLUME_LABEL = 125;
//
// MessageId: ERROR_MOD_NOT_FOUND
//
// MessageText:
//
// The specified module could not be found.
//

const auto ERROR_MOD_NOT_FOUND = 126;
//
// MessageId: ERROR_PROC_NOT_FOUND
//
// MessageText:
//
// The specified procedure could not be found.
//

const auto ERROR_PROC_NOT_FOUND = 127;
//
// MessageId: ERROR_WAIT_NO_CHILDREN
//
// MessageText:
//
// There are no child processes to wait for.
//

const auto ERROR_WAIT_NO_CHILDREN = 128;
//
// MessageId: ERROR_CHILD_NOT_COMPLETE
//
// MessageText:
//
// The %1 application cannot be run in Win32 mode.
//

const auto ERROR_CHILD_NOT_COMPLETE = 129;
//
// MessageId: ERROR_DIRECT_ACCESS_HANDLE
//
// MessageText:
//
// Attempt to use a file handle to an open disk partition for an operation other than raw disk I/O.
//

const auto ERROR_DIRECT_ACCESS_HANDLE = 130;
//
// MessageId: ERROR_NEGATIVE_SEEK
//
// MessageText:
//
// An attempt was made to move the file pointer before the beginning of the file.
//

const auto ERROR_NEGATIVE_SEEK = 131;
//
// MessageId: ERROR_SEEK_ON_DEVICE
//
// MessageText:
//
// The file pointer cannot be set on the specified device or file.
//

const auto ERROR_SEEK_ON_DEVICE = 132;
//
// MessageId: ERROR_IS_JOIN_TARGET
//
// MessageText:
//
// A JOIN or SUBST command cannot be used for a drive that contains previously joined drives.
//

const auto ERROR_IS_JOIN_TARGET = 133;
//
// MessageId: ERROR_IS_JOINED
//
// MessageText:
//
// An attempt was made to use a JOIN or SUBST command on a drive that has already been joined.
//

const auto ERROR_IS_JOINED = 134;
//
// MessageId: ERROR_IS_SUBSTED
//
// MessageText:
//
// An attempt was made to use a JOIN or SUBST command on a drive that has already been substituted.
//

const auto ERROR_IS_SUBSTED = 135;
//
// MessageId: ERROR_NOT_JOINED
//
// MessageText:
//
// The system tried to delete the JOIN of a drive that is not joined.
//

const auto ERROR_NOT_JOINED = 136;
//
// MessageId: ERROR_NOT_SUBSTED
//
// MessageText:
//
// The system tried to delete the substitution of a drive that is not substituted.
//

const auto ERROR_NOT_SUBSTED = 137;
//
// MessageId: ERROR_JOIN_TO_JOIN
//
// MessageText:
//
// The system tried to join a drive to a directory on a joined drive.
//

const auto ERROR_JOIN_TO_JOIN = 138;
//
// MessageId: ERROR_SUBST_TO_SUBST
//
// MessageText:
//
// The system tried to substitute a drive to a directory on a substituted drive.
//

const auto ERROR_SUBST_TO_SUBST = 139;
//
// MessageId: ERROR_JOIN_TO_SUBST
//
// MessageText:
//
// The system tried to join a drive to a directory on a substituted drive.
//

const auto ERROR_JOIN_TO_SUBST = 140;
//
// MessageId: ERROR_SUBST_TO_JOIN
//
// MessageText:
//
// The system tried to SUBST a drive to a directory on a joined drive.
//

const auto ERROR_SUBST_TO_JOIN = 141;
//
// MessageId: ERROR_BUSY_DRIVE
//
// MessageText:
//
// The system cannot perform a JOIN or SUBST at this time.
//

const auto ERROR_BUSY_DRIVE = 142;
//
// MessageId: ERROR_SAME_DRIVE
//
// MessageText:
//
// The system cannot join or substitute a drive to or for a directory on the same drive.
//

const auto ERROR_SAME_DRIVE = 143;
//
// MessageId: ERROR_DIR_NOT_ROOT
//
// MessageText:
//
// The directory is not a subdirectory of the root directory.
//

const auto ERROR_DIR_NOT_ROOT = 144;
//
// MessageId: ERROR_DIR_NOT_EMPTY
//
// MessageText:
//
// The directory is not empty.
//

const auto ERROR_DIR_NOT_EMPTY = 145;
//
// MessageId: ERROR_IS_SUBST_PATH
//
// MessageText:
//
// The path specified is being used in a substitute.
//

const auto ERROR_IS_SUBST_PATH = 146;
//
// MessageId: ERROR_IS_JOIN_PATH
//
// MessageText:
//
// Not enough resources are available to process this command.
//

const auto ERROR_IS_JOIN_PATH = 147;
//
// MessageId: ERROR_PATH_BUSY
//
// MessageText:
//
// The path specified cannot be used at this time.
//

const auto ERROR_PATH_BUSY = 148;
//
// MessageId: ERROR_IS_SUBST_TARGET
//
// MessageText:
//
// An attempt was made to join or substitute a drive for which a directory on the drive is the target of a previous substitute.
//

const auto ERROR_IS_SUBST_TARGET = 149;
//
// MessageId: ERROR_SYSTEM_TRACE
//
// MessageText:
//
// System trace information was not specified in your CONFIG.SYS file, or tracing is disallowed.
//

const auto ERROR_SYSTEM_TRACE = 150;
//
// MessageId: ERROR_INVALID_EVENT_COUNT
//
// MessageText:
//
// The number of specified semaphore events for DosMuxSemWait is not correct.
//

const auto ERROR_INVALID_EVENT_COUNT = 151;
//
// MessageId: ERROR_TOO_MANY_MUXWAITERS
//
// MessageText:
//
// DosMuxSemWait did not execute; too many semaphores are already set.
//

const auto ERROR_TOO_MANY_MUXWAITERS = 152;
//
// MessageId: ERROR_INVALID_LIST_FORMAT
//
// MessageText:
//
// The DosMuxSemWait list is not correct.
//

const auto ERROR_INVALID_LIST_FORMAT = 153;
//
// MessageId: ERROR_LABEL_TOO_LONG
//
// MessageText:
//
// The volume label you entered exceeds the label character limit of the target file system.
//

const auto ERROR_LABEL_TOO_LONG = 154;
//
// MessageId: ERROR_TOO_MANY_TCBS
//
// MessageText:
//
// Cannot create another thread.
//

const auto ERROR_TOO_MANY_TCBS = 155;
//
// MessageId: ERROR_SIGNAL_REFUSED
//
// MessageText:
//
// The recipient process has refused the signal.
//

const auto ERROR_SIGNAL_REFUSED = 156;
//
// MessageId: ERROR_DISCARDED
//
// MessageText:
//
// The segment is already discarded and cannot be locked.
//

const auto ERROR_DISCARDED = 157;
//
// MessageId: ERROR_NOT_LOCKED
//
// MessageText:
//
// The segment is already unlocked.
//

const auto ERROR_NOT_LOCKED = 158;
//
// MessageId: ERROR_BAD_THREADID_ADDR
//
// MessageText:
//
// The address for the thread ID is not correct.
//

const auto ERROR_BAD_THREADID_ADDR = 159;
//
// MessageId: ERROR_BAD_ARGUMENTS
//
// MessageText:
//
// One or more arguments are not correct.
//

const auto ERROR_BAD_ARGUMENTS = 160;
//
// MessageId: ERROR_BAD_PATHNAME
//
// MessageText:
//
// The specified path is invalid.
//

const auto ERROR_BAD_PATHNAME = 161;
//
// MessageId: ERROR_SIGNAL_PENDING
//
// MessageText:
//
// A signal is already pending.
//

const auto ERROR_SIGNAL_PENDING = 162;
//
// MessageId: ERROR_MAX_THRDS_REACHED
//
// MessageText:
//
// No more threads can be created in the system.
//

const auto ERROR_MAX_THRDS_REACHED = 164;
//
// MessageId: ERROR_LOCK_FAILED
//
// MessageText:
//
// Unable to lock a region of a file.
//

const auto ERROR_LOCK_FAILED = 167;
//
// MessageId: ERROR_BUSY
//
// MessageText:
//
// The requested resource is in use.
//

const auto ERROR_BUSY = 170;
//
// MessageId: ERROR_CANCEL_VIOLATION
//
// MessageText:
//
// A lock request was not outstanding for the supplied cancel region.
//

const auto ERROR_CANCEL_VIOLATION = 173;
//
// MessageId: ERROR_ATOMIC_LOCKS_NOT_SUPPORTED
//
// MessageText:
//
// The file system does not support atomic changes to the lock type.
//

const auto ERROR_ATOMIC_LOCKS_NOT_SUPPORTED = 174;
//
// MessageId: ERROR_INVALID_SEGMENT_NUMBER
//
// MessageText:
//
// The system detected a segment number that was not correct.
//

const auto ERROR_INVALID_SEGMENT_NUMBER = 180;
//
// MessageId: ERROR_INVALID_ORDINAL
//
// MessageText:
//
// The operating system cannot run %1.
//

const auto ERROR_INVALID_ORDINAL = 182;
//
// MessageId: ERROR_ALREADY_EXISTS
//
// MessageText:
//
// Cannot create a file when that file already exists.
//

const auto ERROR_ALREADY_EXISTS = 183;
//
// MessageId: ERROR_INVALID_FLAG_NUMBER
//
// MessageText:
//
// The flag passed is not correct.
//

const auto ERROR_INVALID_FLAG_NUMBER = 186;
//
// MessageId: ERROR_SEM_NOT_FOUND
//
// MessageText:
//
// The specified system semaphore name was not found.
//

const auto ERROR_SEM_NOT_FOUND = 187;
//
// MessageId: ERROR_INVALID_STARTING_CODESEG
//
// MessageText:
//
// The operating system cannot run %1.
//

const auto ERROR_INVALID_STARTING_CODESEG = 188;
//
// MessageId: ERROR_INVALID_STACKSEG
//
// MessageText:
//
// The operating system cannot run %1.
//

const auto ERROR_INVALID_STACKSEG = 189;
//
// MessageId: ERROR_INVALID_MODULETYPE
//
// MessageText:
//
// The operating system cannot run %1.
//

const auto ERROR_INVALID_MODULETYPE = 190;
//
// MessageId: ERROR_INVALID_EXE_SIGNATURE
//
// MessageText:
//
// Cannot run %1 in Win32 mode.
//

const auto ERROR_INVALID_EXE_SIGNATURE = 191;
//
// MessageId: ERROR_EXE_MARKED_INVALID
//
// MessageText:
//
// The operating system cannot run %1.
//

const auto ERROR_EXE_MARKED_INVALID = 192;
//
// MessageId: ERROR_BAD_EXE_FORMAT
//
// MessageText:
//
// %1 is not a valid Win32 application.
//

const auto ERROR_BAD_EXE_FORMAT = 193;
//
// MessageId: ERROR_ITERATED_DATA_EXCEEDS_64k
//
// MessageText:
//
// The operating system cannot run %1.
//

const auto ERROR_ITERATED_DATA_EXCEEDS_64k = 194;
//
// MessageId: ERROR_INVALID_MINALLOCSIZE
//
// MessageText:
//
// The operating system cannot run %1.
//

const auto ERROR_INVALID_MINALLOCSIZE = 195;
//
// MessageId: ERROR_DYNLINK_FROM_INVALID_RING
//
// MessageText:
//
// The operating system cannot run this application program.
//

const auto ERROR_DYNLINK_FROM_INVALID_RING = 196;
//
// MessageId: ERROR_IOPL_NOT_ENABLED
//
// MessageText:
//
// The operating system is not presently configured to run this application.
//

const auto ERROR_IOPL_NOT_ENABLED = 197;
//
// MessageId: ERROR_INVALID_SEGDPL
//
// MessageText:
//
// The operating system cannot run %1.
//

const auto ERROR_INVALID_SEGDPL = 198;
//
// MessageId: ERROR_AUTODATASEG_EXCEEDS_64k
//
// MessageText:
//
// The operating system cannot run this application program.
//

const auto ERROR_AUTODATASEG_EXCEEDS_64k = 199;
//
// MessageId: ERROR_RING2SEG_MUST_BE_MOVABLE
//
// MessageText:
//
// The code segment cannot be greater than or equal to 64K.
//

const auto ERROR_RING2SEG_MUST_BE_MOVABLE = 200;
//
// MessageId: ERROR_RELOC_CHAIN_XEEDS_SEGLIM
//
// MessageText:
//
// The operating system cannot run %1.
//

const auto ERROR_RELOC_CHAIN_XEEDS_SEGLIM = 201;
//
// MessageId: ERROR_INFLOOP_IN_RELOC_CHAIN
//
// MessageText:
//
// The operating system cannot run %1.
//

const auto ERROR_INFLOOP_IN_RELOC_CHAIN = 202;
//
// MessageId: ERROR_ENVVAR_NOT_FOUND
//
// MessageText:
//
// The system could not find the environment option that was entered.
//

const auto ERROR_ENVVAR_NOT_FOUND = 203;
//
// MessageId: ERROR_NO_SIGNAL_SENT
//
// MessageText:
//
// No process in the command subtree has a signal handler.
//

const auto ERROR_NO_SIGNAL_SENT = 205;
//
// MessageId: ERROR_FILENAME_EXCED_RANGE
//
// MessageText:
//
// The filename or extension is too long.
//

const auto ERROR_FILENAME_EXCED_RANGE = 206;
//
// MessageId: ERROR_RING2_STACK_IN_USE
//
// MessageText:
//
// The ring 2 stack is in use.
//

const auto ERROR_RING2_STACK_IN_USE = 207;
//
// MessageId: ERROR_META_EXPANSION_TOO_LONG
//
// MessageText:
//
// The global filename characters, * or ?, are entered incorrectly or too many global filename characters are specified.
//

const auto ERROR_META_EXPANSION_TOO_LONG = 208;
//
// MessageId: ERROR_INVALID_SIGNAL_NUMBER
//
// MessageText:
//
// The signal being posted is not correct.
//

const auto ERROR_INVALID_SIGNAL_NUMBER = 209;
//
// MessageId: ERROR_THREAD_1_INACTIVE
//
// MessageText:
//
// The signal handler cannot be set.
//

const auto ERROR_THREAD_1_INACTIVE = 210;
//
// MessageId: ERROR_LOCKED
//
// MessageText:
//
// The segment is locked and cannot be reallocated.
//

const auto ERROR_LOCKED = 212;
//
// MessageId: ERROR_TOO_MANY_MODULES
//
// MessageText:
//
// Too many dynamic-link modules are attached to this program or dynamic-link module.
//

const auto ERROR_TOO_MANY_MODULES = 214;
//
// MessageId: ERROR_NESTING_NOT_ALLOWED
//
// MessageText:
//
// Cannot nest calls to LoadModule.
//

const auto ERROR_NESTING_NOT_ALLOWED = 215;
//
// MessageId: ERROR_EXE_MACHINE_TYPE_MISMATCH
//
// MessageText:
//
// This version of %1 is not compatible with the version of Windows you're running. Check your computer's system information to see whether you need a x86 (32-bit) or x64 (64-bit) version of the program, and then contact the software publisher.
//

const auto ERROR_EXE_MACHINE_TYPE_MISMATCH = 216;
//
// MessageId: ERROR_EXE_CANNOT_MODIFY_SIGNED_BINARY
//
// MessageText:
//
// The image file %1 is signed, unable to modify.
//

const auto ERROR_EXE_CANNOT_MODIFY_SIGNED_BINARY = 217;
//
// MessageId: ERROR_EXE_CANNOT_MODIFY_STRONG_SIGNED_BINARY
//
// MessageText:
//
// The image file %1 is strong signed, unable to modify.
//

const auto ERROR_EXE_CANNOT_MODIFY_STRONG_SIGNED_BINARY = 218;
//
// MessageId: ERROR_FILE_CHECKED_OUT
//
// MessageText:
//
// This file is checked out or locked for editing by another user.
//

const auto ERROR_FILE_CHECKED_OUT = 220;
//
// MessageId: ERROR_CHECKOUT_REQUIRED
//
// MessageText:
//
// The file must be checked out before saving changes.
//

const auto ERROR_CHECKOUT_REQUIRED = 221;
//
// MessageId: ERROR_BAD_FILE_TYPE
//
// MessageText:
//
// The file type being saved or retrieved has been blocked.
//

const auto ERROR_BAD_FILE_TYPE = 222;
//
// MessageId: ERROR_FILE_TOO_LARGE
//
// MessageText:
//
// The file size exceeds the limit allowed and cannot be saved.
//

const auto ERROR_FILE_TOO_LARGE = 223;
//
// MessageId: ERROR_FORMS_AUTH_REQUIRED
//
// MessageText:
//
// Access Denied. Before opening files in this location, you must first browse to the web site and select the option to login automatically.
//

const auto ERROR_FORMS_AUTH_REQUIRED = 224;
//
// MessageId: ERROR_VIRUS_INFECTED
//
// MessageText:
//
// Operation did not complete successfully because the file contains a virus.
//

const auto ERROR_VIRUS_INFECTED = 225;
//
// MessageId: ERROR_VIRUS_DELETED
//
// MessageText:
//
// This file contains a virus and cannot be opened. Due to the nature of this virus, the file has been removed from this location.
//

const auto ERROR_VIRUS_DELETED = 226;
//
// MessageId: ERROR_PIPE_LOCAL
//
// MessageText:
//
// The pipe is local.
//

const auto ERROR_PIPE_LOCAL = 229;
//
// MessageId: ERROR_BAD_PIPE
//
// MessageText:
//
// The pipe state is invalid.
//

const auto ERROR_BAD_PIPE = 230;
//
// MessageId: ERROR_PIPE_BUSY
//
// MessageText:
//
// All pipe instances are busy.
//

const auto ERROR_PIPE_BUSY = 231;
//
// MessageId: ERROR_NO_DATA
//
// MessageText:
//
// The pipe is being closed.
//

const auto ERROR_NO_DATA = 232;
//
// MessageId: ERROR_PIPE_NOT_CONNECTED
//
// MessageText:
//
// No process is on the other end of the pipe.
//

const auto ERROR_PIPE_NOT_CONNECTED = 233;
//
// MessageId: ERROR_MORE_DATA
//
// MessageText:
//
// More data is available.
//

const auto ERROR_MORE_DATA = 234;
//
// MessageId: ERROR_VC_DISCONNECTED
//
// MessageText:
//
// The session was canceled.
//

const auto ERROR_VC_DISCONNECTED = 240;
//
// MessageId: ERROR_INVALID_EA_NAME
//
// MessageText:
//
// The specified extended attribute name was invalid.
//

const auto ERROR_INVALID_EA_NAME = 254;
//
// MessageId: ERROR_EA_LIST_INCONSISTENT
//
// MessageText:
//
// The extended attributes are inconsistent.
//

const auto ERROR_EA_LIST_INCONSISTENT = 255;
//
// MessageId: WAIT_TIMEOUT
//
// MessageText:
//
// The wait operation timed out.
//

const auto WAIT_TIMEOUT = 258;
//
// MessageId: ERROR_NO_MORE_ITEMS
//
// MessageText:
//
// No more data is available.
//

const auto ERROR_NO_MORE_ITEMS = 259;
//
// MessageId: ERROR_CANNOT_COPY
//
// MessageText:
//
// The copy functions cannot be used.
//

const auto ERROR_CANNOT_COPY = 266;
//
// MessageId: ERROR_DIRECTORY
//
// MessageText:
//
// The directory name is invalid.
//

const auto ERROR_DIRECTORY = 267;
//
// MessageId: ERROR_EAS_DIDNT_FIT
//
// MessageText:
//
// The extended attributes did not fit in the buffer.
//

const auto ERROR_EAS_DIDNT_FIT = 275;
//
// MessageId: ERROR_EA_FILE_CORRUPT
//
// MessageText:
//
// The extended attribute file on the mounted file system is corrupt.
//

const auto ERROR_EA_FILE_CORRUPT = 276;
//
// MessageId: ERROR_EA_TABLE_FULL
//
// MessageText:
//
// The extended attribute table file is full.
//

const auto ERROR_EA_TABLE_FULL = 277;
//
// MessageId: ERROR_INVALID_EA_HANDLE
//
// MessageText:
//
// The specified extended attribute handle is invalid.
//

const auto ERROR_INVALID_EA_HANDLE = 278;
//
// MessageId: ERROR_EAS_NOT_SUPPORTED
//
// MessageText:
//
// The mounted file system does not support extended attributes.
//

const auto ERROR_EAS_NOT_SUPPORTED = 282;
//
// MessageId: ERROR_NOT_OWNER
//
// MessageText:
//
// Attempt to release mutex not owned by caller.
//

const auto ERROR_NOT_OWNER = 288;
//
// MessageId: ERROR_TOO_MANY_POSTS
//
// MessageText:
//
// Too many posts were made to a semaphore.
//

const auto ERROR_TOO_MANY_POSTS = 298;
//
// MessageId: ERROR_PARTIAL_COPY
//
// MessageText:
//
// Only part of a ReadProcessMemory or WriteProcessMemory request was completed.
//

const auto ERROR_PARTIAL_COPY = 299;
//
// MessageId: ERROR_OPLOCK_NOT_GRANTED
//
// MessageText:
//
// The oplock request is denied.
//

const auto ERROR_OPLOCK_NOT_GRANTED = 300;
//
// MessageId: ERROR_INVALID_OPLOCK_PROTOCOL
//
// MessageText:
//
// An invalid oplock acknowledgment was received by the system.
//

const auto ERROR_INVALID_OPLOCK_PROTOCOL = 301;
//
// MessageId: ERROR_DISK_TOO_FRAGMENTED
//
// MessageText:
//
// The volume is too fragmented to complete this operation.
//

const auto ERROR_DISK_TOO_FRAGMENTED = 302;
//
// MessageId: ERROR_DELETE_PENDING
//
// MessageText:
//
// The file cannot be opened because it is in the process of being deleted.
//

const auto ERROR_DELETE_PENDING = 303;
//
// MessageId: ERROR_MR_MID_NOT_FOUND
//
// MessageText:
//
// The system cannot find message text for message number 0x%1 in the message file for %2.
//

const auto ERROR_MR_MID_NOT_FOUND = 317;
//
// MessageId: ERROR_SCOPE_NOT_FOUND
//
// MessageText:
//
// The scope specified was not found.
//

const auto ERROR_SCOPE_NOT_FOUND = 318;
//
// MessageId: ERROR_FAIL_NOACTION_REBOOT
//
// MessageText:
//
// No action was taken as a system reboot is required.
//

const auto ERROR_FAIL_NOACTION_REBOOT = 350;
//
// MessageId: ERROR_FAIL_SHUTDOWN
//
// MessageText:
//
// The shutdown operation failed.
//

const auto ERROR_FAIL_SHUTDOWN = 351;
//
// MessageId: ERROR_FAIL_RESTART
//
// MessageText:
//
// The restart operation failed.
//

const auto ERROR_FAIL_RESTART = 352;
//
// MessageId: ERROR_MAX_SESSIONS_REACHED
//
// MessageText:
//
// The maximum number of sessions has been reached.
//

const auto ERROR_MAX_SESSIONS_REACHED = 353;
//
// MessageId: ERROR_THREAD_MODE_ALREADY_BACKGROUND
//
// MessageText:
//
// The thread is already in background processing mode.
//

const auto ERROR_THREAD_MODE_ALREADY_BACKGROUND = 400;
//
// MessageId: ERROR_THREAD_MODE_NOT_BACKGROUND
//
// MessageText:
//
// The thread is not in background processing mode.
//

const auto ERROR_THREAD_MODE_NOT_BACKGROUND = 401;
//
// MessageId: ERROR_PROCESS_MODE_ALREADY_BACKGROUND
//
// MessageText:
//
// The process is already in background processing mode.
//

const auto ERROR_PROCESS_MODE_ALREADY_BACKGROUND = 402;
//
// MessageId: ERROR_PROCESS_MODE_NOT_BACKGROUND
//
// MessageText:
//
// The process is not in background processing mode.
//

const auto ERROR_PROCESS_MODE_NOT_BACKGROUND = 403;
//
// MessageId: ERROR_INVALID_ADDRESS
//
// MessageText:
//
// Attempt to access invalid address.
//

const auto ERROR_INVALID_ADDRESS = 487;
//
// MessageId: ERROR_USER_PROFILE_LOAD
//
// MessageText:
//
// User profile cannot be loaded.
//

const auto ERROR_USER_PROFILE_LOAD = 500;
//
// MessageId: ERROR_ARITHMETIC_OVERFLOW
//
// MessageText:
//
// Arithmetic result exceeded 32 bits.
//

const auto ERROR_ARITHMETIC_OVERFLOW = 534;
//
// MessageId: ERROR_PIPE_CONNECTED
//
// MessageText:
//
// There is a process on other end of the pipe.
//

const auto ERROR_PIPE_CONNECTED = 535;
//
// MessageId: ERROR_PIPE_LISTENING
//
// MessageText:
//
// Waiting for a process to open the other end of the pipe.
//

const auto ERROR_PIPE_LISTENING = 536;
//
// MessageId: ERROR_VERIFIER_STOP
//
// MessageText:
//
// Application verifier has found an error in the current process.
//

const auto ERROR_VERIFIER_STOP = 537;
//
// MessageId: ERROR_ABIOS_ERROR
//
// MessageText:
//
// An error occurred in the ABIOS subsystem.
//

const auto ERROR_ABIOS_ERROR = 538;
//
// MessageId: ERROR_WX86_WARNING
//
// MessageText:
//
// A warning occurred in the WX86 subsystem.
//

const auto ERROR_WX86_WARNING = 539;
//
// MessageId: ERROR_WX86_ERROR
//
// MessageText:
//
// An error occurred in the WX86 subsystem.
//

const auto ERROR_WX86_ERROR = 540;
//
// MessageId: ERROR_TIMER_NOT_CANCELED
//
// MessageText:
//
// An attempt was made to cancel or set a timer that has an associated APC and the subject thread is not the thread that originally set the timer with an associated APC routine.
//

const auto ERROR_TIMER_NOT_CANCELED = 541;
//
// MessageId: ERROR_UNWIND
//
// MessageText:
//
// Unwind exception code.
//

const auto ERROR_UNWIND = 542;
//
// MessageId: ERROR_BAD_STACK
//
// MessageText:
//
// An invalid or unaligned stack was encountered during an unwind operation.
//

const auto ERROR_BAD_STACK = 543;
//
// MessageId: ERROR_INVALID_UNWIND_TARGET
//
// MessageText:
//
// An invalid unwind target was encountered during an unwind operation.
//

const auto ERROR_INVALID_UNWIND_TARGET = 544;
//
// MessageId: ERROR_INVALID_PORT_ATTRIBUTES
//
// MessageText:
//
// Invalid Object Attributes specified to NtCreatePort or invalid Port Attributes specified to NtConnectPort
//

const auto ERROR_INVALID_PORT_ATTRIBUTES = 545;
//
// MessageId: ERROR_PORT_MESSAGE_TOO_LONG
//
// MessageText:
//
// Length of message passed to NtRequestPort or NtRequestWaitReplyPort was longer than the maximum message allowed by the port.
//

const auto ERROR_PORT_MESSAGE_TOO_LONG = 546;
//
// MessageId: ERROR_INVALID_QUOTA_LOWER
//
// MessageText:
//
// An attempt was made to lower a quota limit below the current usage.
//

const auto ERROR_INVALID_QUOTA_LOWER = 547;
//
// MessageId: ERROR_DEVICE_ALREADY_ATTACHED
//
// MessageText:
//
// An attempt was made to attach to a device that was already attached to another device.
//

const auto ERROR_DEVICE_ALREADY_ATTACHED = 548;
//
// MessageId: ERROR_INSTRUCTION_MISALIGNMENT
//
// MessageText:
//
// An attempt was made to execute an instruction at an unaligned address and the host system does not support unaligned instruction references.
//

const auto ERROR_INSTRUCTION_MISALIGNMENT = 549;
//
// MessageId: ERROR_PROFILING_NOT_STARTED
//
// MessageText:
//
// Profiling not started.
//

const auto ERROR_PROFILING_NOT_STARTED = 550;
//
// MessageId: ERROR_PROFILING_NOT_STOPPED
//
// MessageText:
//
// Profiling not stopped.
//

const auto ERROR_PROFILING_NOT_STOPPED = 551;
//
// MessageId: ERROR_COULD_NOT_INTERPRET
//
// MessageText:
//
// The passed ACL did not contain the minimum required information.
//

const auto ERROR_COULD_NOT_INTERPRET = 552;
//
// MessageId: ERROR_PROFILING_AT_LIMIT
//
// MessageText:
//
// The number of active profiling objects is at the maximum and no more may be started.
//

const auto ERROR_PROFILING_AT_LIMIT = 553;
//
// MessageId: ERROR_CANT_WAIT
//
// MessageText:
//
// Used to indicate that an operation cannot continue without blocking for I/O.
//

const auto ERROR_CANT_WAIT = 554;
//
// MessageId: ERROR_CANT_TERMINATE_SELF
//
// MessageText:
//
// Indicates that a thread attempted to terminate itself by default (called NtTerminateThread with NUL and it was the last thread in the current process.
//

const auto ERROR_CANT_TERMINATE_SELF = 555;
//
// MessageId: ERROR_UNEXPECTED_MM_CREATE_ERR
//
// MessageText:
//
// If an MM error is returned which is not defined in the standard FsRtl filter, it is converted to one of the following errors which is guaranteed to be in the filter.
// In this case information is lost, however, the filter correctly handles the exception.
//

const auto ERROR_UNEXPECTED_MM_CREATE_ERR = 556;
//
// MessageId: ERROR_UNEXPECTED_MM_MAP_ERROR
//
// MessageText:
//
// If an MM error is returned which is not defined in the standard FsRtl filter, it is converted to one of the following errors which is guaranteed to be in the filter.
// In this case information is lost, however, the filter correctly handles the exception.
//

const auto ERROR_UNEXPECTED_MM_MAP_ERROR = 557;
//
// MessageId: ERROR_UNEXPECTED_MM_EXTEND_ERR
//
// MessageText:
//
// If an MM error is returned which is not defined in the standard FsRtl filter, it is converted to one of the following errors which is guaranteed to be in the filter.
// In this case information is lost, however, the filter correctly handles the exception.
//

const auto ERROR_UNEXPECTED_MM_EXTEND_ERR = 558;
//
// MessageId: ERROR_BAD_FUNCTION_TABLE
//
// MessageText:
//
// A malformed function table was encountered during an unwind operation.
//

const auto ERROR_BAD_FUNCTION_TABLE = 559;
//
// MessageId: ERROR_NO_GUID_TRANSLATION
//
// MessageText:
//
// Indicates that an attempt was made to assign protection to a file system file or directory and one of the SIDs in the security descriptor could not be translated into a GUID that could be stored by the file system.
// This causes the protection attempt to fail, which may cause a file creation attempt to fail.
//

const auto ERROR_NO_GUID_TRANSLATION = 560;
//
// MessageId: ERROR_INVALID_LDT_SIZE
//
// MessageText:
//
// Indicates that an attempt was made to grow an LDT by setting its size, or that the size was not an even number of selectors.
//

const auto ERROR_INVALID_LDT_SIZE = 561;
//
// MessageId: ERROR_INVALID_LDT_OFFSET
//
// MessageText:
//
// Indicates that the starting value for the LDT information was not an integral multiple of the selector size.
//

const auto ERROR_INVALID_LDT_OFFSET = 563;
//
// MessageId: ERROR_INVALID_LDT_DESCRIPTOR
//
// MessageText:
//
// Indicates that the user supplied an invalid descriptor when trying to set up Ldt descriptors.
//

const auto ERROR_INVALID_LDT_DESCRIPTOR = 564;
//
// MessageId: ERROR_TOO_MANY_THREADS
//
// MessageText:
//
// Indicates a process has too many threads to perform the requested action. For example, assignment of a primary token may only be performed when a process has zero or one threads.
//

const auto ERROR_TOO_MANY_THREADS = 565;
//
// MessageId: ERROR_THREAD_NOT_IN_PROCESS
//
// MessageText:
//
// An attempt was made to operate on a thread within a specific process, but the thread specified is not in the process specified.
//

const auto ERROR_THREAD_NOT_IN_PROCESS = 566;
//
// MessageId: ERROR_PAGEFILE_QUOTA_EXCEEDED
//
// MessageText:
//
// Page file quota was exceeded.
//

const auto ERROR_PAGEFILE_QUOTA_EXCEEDED = 567;
//
// MessageId: ERROR_LOGON_SERVER_CONFLICT
//
// MessageText:
//
// The Netlogon service cannot start because another Netlogon service running in the domain conflicts with the specified role.
//

const auto ERROR_LOGON_SERVER_CONFLICT = 568;
//
// MessageId: ERROR_SYNCHRONIZATION_REQUIRED
//
// MessageText:
//
// The SAM database on a Windows Server is significantly out of synchronization with the copy on the Domain Controller. A complete synchronization is required.
//

const auto ERROR_SYNCHRONIZATION_REQUIRED = 569;
//
// MessageId: ERROR_NET_OPEN_FAILED
//
// MessageText:
//
// The NtCreateFile API failed. This error should never be returned to an application, it is a place holder for the Windows Lan Manager Redirector to use in its internal error mapping routines.
//

const auto ERROR_NET_OPEN_FAILED = 570;
//
// MessageId: ERROR_IO_PRIVILEGE_FAILED
//
// MessageText:
//
// {Privilege Failed}
// The I/O permissions for the process could not be changed.
//

const auto ERROR_IO_PRIVILEGE_FAILED = 571;
//
// MessageId: ERROR_CONTROL_C_EXIT
//
// MessageText:
//
// {Application Exit by CTRL+C}
// The application terminated as a result of a CTRL+C.
//

const auto ERROR_CONTROL_C_EXIT = 572;
//
// MessageId: ERROR_MISSING_SYSTEMFILE
//
// MessageText:
//
// {Missing System File}
// The required system file %hs is bad or missing.
//

const auto ERROR_MISSING_SYSTEMFILE = 573;
//
// MessageId: ERROR_UNHANDLED_EXCEPTION
//
// MessageText:
//
// {Application Error}
// The exception %s 0x%08lx) occurred in the application at location 0x%08lx.
//

const auto ERROR_UNHANDLED_EXCEPTION = 574;
//
// MessageId: ERROR_APP_INIT_FAILURE
//
// MessageText:
//
// {Application Error}
// The application failed to initialize properly 0x%lx). Click OK to terminate the application.
//

const auto ERROR_APP_INIT_FAILURE = 575;
//
// MessageId: ERROR_PAGEFILE_CREATE_FAILED
//
// MessageText:
//
// {Unable to Create Paging File}
// The creation of the paging file %hs failed (%lx). The requested size was %ld.
//

const auto ERROR_PAGEFILE_CREATE_FAILED = 576;
//
// MessageId: ERROR_INVALID_IMAGE_HASH
//
// MessageText:
//
// Windows cannot verify the digital signature for this file. A recent hardware or software change might have installed a file that is signed incorrectly or damaged, or that might be malicious software from an unknown source.
//

const auto ERROR_INVALID_IMAGE_HASH = 577;
//
// MessageId: ERROR_NO_PAGEFILE
//
// MessageText:
//
// {No Paging File Specified}
// No paging file was specified in the system configuration.
//

const auto ERROR_NO_PAGEFILE = 578;
//
// MessageId: ERROR_ILLEGAL_FLOAT_CONTEXT
//
// MessageText:
//
// {EXCEPTION}
// A real-mode application issued a floating-point instruction and floating-point hardware is not present.
//

const auto ERROR_ILLEGAL_FLOAT_CONTEXT = 579;
//
// MessageId: ERROR_NO_EVENT_PAIR
//
// MessageText:
//
// An event pair synchronization operation was performed using the thread specific client/server event pair object, but no event pair object was associated with the thread.
//

const auto ERROR_NO_EVENT_PAIR = 580;
//
// MessageId: ERROR_DOMAIN_CTRLR_CONFIG_ERROR
//
// MessageText:
//
// A Windows Server has an incorrect configuration.
//

const auto ERROR_DOMAIN_CTRLR_CONFIG_ERROR = 581;
//
// MessageId: ERROR_ILLEGAL_CHARACTER
//
// MessageText:
//
// An illegal character was encountered. For a multi-byte character set this includes a lead byte without a succeeding trail byte. For the Unicode character set this includes the characters 0xFFFF and 0xFFFE.
//

const auto ERROR_ILLEGAL_CHARACTER = 582;
//
// MessageId: ERROR_UNDEFINED_CHARACTER
//
// MessageText:
//
// The Unicode character is not defined in the Unicode character set installed on the system.
//

const auto ERROR_UNDEFINED_CHARACTER = 583;
//
// MessageId: ERROR_FLOPPY_VOLUME
//
// MessageText:
//
// The paging file cannot be created on a floppy diskette.
//

const auto ERROR_FLOPPY_VOLUME = 584;
//
// MessageId: ERROR_BIOS_FAILED_TO_CONNECT_INTERRUPT
//
// MessageText:
//
// The system BIOS failed to connect a system interrupt to the device or bus for which the device is connected.
//

const auto ERROR_BIOS_FAILED_TO_CONNECT_INTERRUPT = 585;
//
// MessageId: ERROR_BACKUP_CONTROLLER
//
// MessageText:
//
// This operation is only allowed for the Primary Domain Controller of the domain.
//

const auto ERROR_BACKUP_CONTROLLER = 586;
//
// MessageId: ERROR_MUTANT_LIMIT_EXCEEDED
//
// MessageText:
//
// An attempt was made to acquire a mutant such that its maximum count would have been exceeded.
//

const auto ERROR_MUTANT_LIMIT_EXCEEDED = 587;
//
// MessageId: ERROR_FS_DRIVER_REQUIRED
//
// MessageText:
//
// A volume has been accessed for which a file system driver is required that has not yet been loaded.
//

const auto ERROR_FS_DRIVER_REQUIRED = 588;
//
// MessageId: ERROR_CANNOT_LOAD_REGISTRY_FILE
//
// MessageText:
//
// {Registry File Failure}
// The registry cannot load the hive (file):
// %hs
// or its log or alternate.
// It is corrupt, absent, or not writable.
//

const auto ERROR_CANNOT_LOAD_REGISTRY_FILE = 589;
//
// MessageId: ERROR_DEBUG_ATTACH_FAILED
//
// MessageText:
//
// {Unexpected Failure in DebugActiveProcess}
// An unexpected failure occurred while processing a DebugActiveProcess API request. You may choose OK to terminate the process, or Cancel to ignore the error.
//

const auto ERROR_DEBUG_ATTACH_FAILED = 590;
//
// MessageId: ERROR_SYSTEM_PROCESS_TERMINATED
//
// MessageText:
//
// {Fatal System Error}
// The %hs system process terminated unexpectedly with a status of 0x%08x 0x%08x 0x%08x).
// The system has b…