/*
 * ntstatus.d
 *
 * This is a binding of ntstatus.h to D. The original notices are preserved
 * below.
 *
 * Author: Dave Wilkinson
 * Originated: November 24th 2009
 *
 */

module binding.win32.ntstatus;

import binding.win32.windef;
import binding.win32.winnt;

typedef LONG NTSTATUS;

/*++ BUILD Version: 0005    // Increment this if a change has global effects

Copyright (c) Microsoft Corporation.  All rights reserved.

Module Name:

    ntstatus.h

Abstract:

    Constant definitions for the NTSTATUS values.

Author:

    Portable Systems Group 30-Mar-1989

Revision History:

Notes:

    This file is generated by the MC tool from the ntstatus.mc file.

    Please add new error values to the end of the file. To do otherwise
    will jumble the error values.

--*/

// begin_ntsecapi

/*lint -save -e767 */  // Don't complain about different definitions // winnt


/////////////////////////////////////////////////////////////////////////
//
// Please update FACILITY_MAXIMUM_VALUE when adding new facility values.
//
//
/////////////////////////////////////////////////////////////////////////

/////////////////////////////////////////////////////////////////////////
//
// Standard Success values
//
//
/////////////////////////////////////////////////////////////////////////


//
// The success status codes 0 - 63 are reserved for wait completion status.
// FacilityCodes 0x5 - 0xF have been allocated by various drivers.
//
const auto STATUS_SUCCESS                           = (cast(NTSTATUS)0x00000000L) ; // ntsubauth

//
//  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_VIDEO                    = 0x1B;
const auto FACILITY_USB_ERROR_CODE           = 0x10;
const auto FACILITY_TRANSACTION              = 0x19;
const auto FACILITY_TERMINAL_SERVER          = 0xA;
const auto FACILITY_SXS_ERROR_CODE           = 0x15;
const auto FACILITY_NTSSPI                   = 0x9;
const auto FACILITY_RPC_STUBS                = 0x3;
const auto FACILITY_RPC_RUNTIME              = 0x2;
const auto FACILITY_NTWIN32                  = 0x7;
const auto FACILITY_NDIS_ERROR_CODE          = 0x23;
const auto FACILTIY_MUI_ERROR_CODE           = 0xB;
const auto FACILITY_MONITOR                  = 0x1D;
const auto FACILITY_MAXIMUM_VALUE            = 0x37;
const auto FACILITY_IPSEC                    = 0x36;
const auto FACILITY_IO_ERROR_CODE            = 0x4;
const auto FACILITY_HYPERVISOR               = 0x35;
const auto FACILITY_HID_ERROR_CODE           = 0x11;
const auto FACILITY_GRAPHICS_KERNEL          = 0x1E;
const auto FACILITY_FWP_ERROR_CODE           = 0x22;
const auto FACILITY_FVE_ERROR_CODE           = 0x21;
const auto FACILITY_FIREWIRE_ERROR_CODE      = 0x12;
const auto FACILITY_FILTER_MANAGER           = 0x1C;
const auto FACILITY_DRIVER_FRAMEWORK         = 0x20;
const auto FACILITY_DEBUGGER                 = 0x1;
const auto FACILITY_COMMONLOG                = 0x1A;
const auto FACILITY_CLUSTER_ERROR_CODE       = 0x13;
const auto FACILITY_ACPI_ERROR_CODE          = 0x14;


//
// Define the severity codes
//
const auto STATUS_SEVERITY_WARNING           = 0x2;
const auto STATUS_SEVERITY_SUCCESS           = 0x0;
const auto STATUS_SEVERITY_INFORMATIONAL     = 0x1;
const auto STATUS_SEVERITY_ERROR             = 0x3;


//
// MessageId: STATUS_WAIT_0
//
// MessageText:
//
//  STATUS_WAIT_0
//
//const auto STATUS_WAIT_0                     = (cast(NTSTATUS)0x00000000L)    ; // winnt

//
// MessageId: STATUS_WAIT_1
//
// MessageText:
//
//  STATUS_WAIT_1
//
const auto STATUS_WAIT_1                     = (cast(NTSTATUS)0x00000001L);

//
// MessageId: STATUS_WAIT_2
//
// MessageText:
//
//  STATUS_WAIT_2
//
const auto STATUS_WAIT_2                     = (cast(NTSTATUS)0x00000002L);

//
// MessageId: STATUS_WAIT_3
//
// MessageText:
//
//  STATUS_WAIT_3
//
const auto STATUS_WAIT_3                     = (cast(NTSTATUS)0x00000003L);

//
// MessageId: STATUS_WAIT_63
//
// MessageText:
//
//  STATUS_WAIT_63
//
const auto STATUS_WAIT_63                    = (cast(NTSTATUS)0x0000003FL);


//
// The success status codes 128 - 191 are reserved for wait completion
// status with an abandoned mutant object.
//
const auto STATUS_ABANDONED                         = (cast(NTSTATUS)0x00000080L);

//
// MessageId: STATUS_ABANDONED_WAIT_0
//
// MessageText:
//
//  STATUS_ABANDONED_WAIT_0
//
//const auto STATUS_ABANDONED_WAIT_0           = (cast(NTSTATUS)0x00000080L)    ; // winnt

//
// MessageId: STATUS_ABANDONED_WAIT_63
//
// MessageText:
//
//  STATUS_ABANDONED_WAIT_63
//
const auto STATUS_ABANDONED_WAIT_63          = (cast(NTSTATUS)0x000000BFL);


//
// The success status codes 256, 257, 258, and 258 are reserved for
// User APC, Kernel APC, Alerted, and Timeout.
//
//
// MessageId: STATUS_USER_APC
//
// MessageText:
//
//  STATUS_USER_APC
//
//const auto STATUS_USER_APC                   = (cast(NTSTATUS)0x000000C0L)    ; // winnt

//
// MessageId: STATUS_KERNEL_APC
//
// MessageText:
//
//  STATUS_KERNEL_APC
//
const auto STATUS_KERNEL_APC                 = (cast(NTSTATUS)0x00000100L);

//
// MessageId: STATUS_ALERTED
//
// MessageText:
//
//  STATUS_ALERTED
//
const auto STATUS_ALERTED                    = (cast(NTSTATUS)0x00000101L);

//
// MessageId: STATUS_TIMEOUT
//
// MessageText:
//
//  STATUS_TIMEOUT
//
const auto STATUS_TIMEOUT                    = (cast(NTSTATUS)0x00000102L)    ; // winnt

//
// MessageId: STATUS_PENDING
//
// MessageText:
//
// The operation that was requested is pending completion.
//
//const auto STATUS_PENDING                    = (cast(NTSTATUS)0x00000103L)    ; // winnt

//
// MessageId: STATUS_REPARSE
//
// MessageText:
//
// A reparse should be performed by the Object Manager since the name of the file resulted in a symbolic link.
//
const auto STATUS_REPARSE                    = (cast(NTSTATUS)0x00000104L);

//
// MessageId: STATUS_MORE_ENTRIES
//
// MessageText:
//
// Returned by enumeration APIs to indicate more information is available to successive calls.
//
const auto STATUS_MORE_ENTRIES               = (cast(NTSTATUS)0x00000105L);

//
// MessageId: STATUS_NOT_ALL_ASSIGNED
//
// MessageText:
//
// Indicates not all privileges or groups referenced are assigned to the caller.
// This allows, for example, all privileges to be disabled without having to know exactly which privileges are assigned.
//
const auto STATUS_NOT_ALL_ASSIGNED           = (cast(NTSTATUS)0x00000106L);

//
// MessageId: STATUS_SOME_NOT_MAPPED
//
// MessageText:
//
// Some of the information to be translated has not been translated.
//
const auto STATUS_SOME_NOT_MAPPED            = (cast(NTSTATUS)0x00000107L);

//
// MessageId: STATUS_OPLOCK_BREAK_IN_PROGRESS
//
// MessageText:
//
// An open/create operation completed while an oplock break is underway.
//
const auto STATUS_OPLOCK_BREAK_IN_PROGRESS   = (cast(NTSTATUS)0x00000108L);

//
// MessageId: STATUS_VOLUME_MOUNTED
//
// MessageText:
//
// A new volume has been mounted by a file system.
//
const auto STATUS_VOLUME_MOUNTED             = (cast(NTSTATUS)0x00000109L);

//
// MessageId: STATUS_RXACT_COMMITTED
//
// MessageText:
//
// This success level status indicates that the transaction state already exists for the registry sub-tree, but that a transaction commit was previously aborted.
// The commit has now been completed.
//
const auto STATUS_RXACT_COMMITTED            = (cast(NTSTATUS)0x0000010AL);

//
// MessageId: STATUS_NOTIFY_CLEANUP
//
// MessageText:
//
// This indicates that a notify change request has been completed due to closing the handle which made the notify change request.
//
const auto STATUS_NOTIFY_CLEANUP             = (cast(NTSTATUS)0x0000010BL);

//
// MessageId: STATUS_NOTIFY_ENUM_DIR
//
// MessageText:
//
// This indicates that a notify change request is being completed and that the information is not being returned in the caller's buffer.
// The caller now needs to enumerate the files to find the changes.
//
const auto STATUS_NOTIFY_ENUM_DIR            = (cast(NTSTATUS)0x0000010CL);

//
// MessageId: STATUS_NO_QUOTAS_FOR_ACCOUNT
//
// MessageText:
//
// {No Quotas}
// No system quota limits are specifically set for this account.
//
const auto STATUS_NO_QUOTAS_FOR_ACCOUNT      = (cast(NTSTATUS)0x0000010DL);

//
// MessageId: STATUS_PRIMARY_TRANSPORT_CONNECT_FAILED
//
// MessageText:
//
// {Connect Failure on Primary Transport}
// An attempt was made to connect to the remote server %hs on the primary transport, but the connection failed.
// The computer WAS able to connect on a secondary transport.
//
const auto STATUS_PRIMARY_TRANSPORT_CONNECT_FAILED  = (cast(NTSTATUS)0x0000010EL);

//
// MessageId: STATUS_PAGE_FAULT_TRANSITION
//
// MessageText:
//
// Page fault was a transition fault.
//
const auto STATUS_PAGE_FAULT_TRANSITION      = (cast(NTSTATUS)0x00000110L);

//
// MessageId: STATUS_PAGE_FAULT_DEMAND_ZERO
//
// MessageText:
//
// Page fault was a demand zero fault.
//
const auto STATUS_PAGE_FAULT_DEMAND_ZERO     = (cast(NTSTATUS)0x00000111L);

//
// MessageId: STATUS_PAGE_FAULT_COPY_ON_WRITE
//
// MessageText:
//
// Page fault was a demand zero fault.
//
const auto STATUS_PAGE_FAULT_COPY_ON_WRITE   = (cast(NTSTATUS)0x00000112L);

//
// MessageId: STATUS_PAGE_FAULT_GUARD_PAGE
//
// MessageText:
//
// Page fault was a demand zero fault.
//
const auto STATUS_PAGE_FAULT_GUARD_PAGE      = (cast(NTSTATUS)0x00000113L);

//
// MessageId: STATUS_PAGE_FAULT_PAGING_FILE
//
// MessageText:
//
// Page fault was satisfied by reading from a secondary storage device.
//
const auto STATUS_PAGE_FAULT_PAGING_FILE     = (cast(NTSTATUS)0x00000114L);

//
// MessageId: STATUS_CACHE_PAGE_LOCKED
//
// MessageText:
//
// Cached page was locked during operation.
//
const auto STATUS_CACHE_PAGE_LOCKED          = (cast(NTSTATUS)0x00000115L);

//
// MessageId: STATUS_CRASH_DUMP
//
// MessageText:
//
// Crash dump exists in paging file.
//
const auto STATUS_CRASH_DUMP                 = (cast(NTSTATUS)0x00000116L);

//
// MessageId: STATUS_BUFFER_ALL_ZEROS
//
// MessageText:
//
// Specified buffer contains all zeros.
//
const auto STATUS_BUFFER_ALL_ZEROS           = (cast(NTSTATUS)0x00000117L);

//
// MessageId: STATUS_REPARSE_OBJECT
//
// MessageText:
//
// A reparse should be performed by the Object Manager since the name of the file resulted in a symbolic link.
//
const auto STATUS_REPARSE_OBJECT             = (cast(NTSTATUS)0x00000118L);

//
// MessageId: STATUS_RESOURCE_REQUIREMENTS_CHANGED
//
// MessageText:
//
// The device has succeeded a query-stop and its resource requirements have changed.
//
const auto STATUS_RESOURCE_REQUIREMENTS_CHANGED  = (cast(NTSTATUS)0x00000119L);

//
// MessageId: STATUS_TRANSLATION_COMPLETE
//
// MessageText:
//
// The translator has translated these resources into the global space and no further translations should be performed.
//
const auto STATUS_TRANSLATION_COMPLETE       = (cast(NTSTATUS)0x00000120L);

//
// MessageId: STATUS_DS_MEMBERSHIP_EVALUATED_LOCALLY
//
// MessageText:
//
// The directory service evaluated group memberships locally, as it was unable to contact a global catalog server.
//
const auto STATUS_DS_MEMBERSHIP_EVALUATED_LOCALLY  = (cast(NTSTATUS)0x00000121L);

//
// MessageId: STATUS_NOTHING_TO_TERMINATE
//
// MessageText:
//
// A process being terminated has no threads to terminate.
//
const auto STATUS_NOTHING_TO_TERMINATE       = (cast(NTSTATUS)0x00000122L);

//
// MessageId: STATUS_PROCESS_NOT_IN_JOB
//
// MessageText:
//
// The specified process is not part of a job.
//
const auto STATUS_PROCESS_NOT_IN_JOB         = (cast(NTSTATUS)0x00000123L);

//
// MessageId: STATUS_PROCESS_IN_JOB
//
// MessageText:
//
// The specified process is part of a job.
//
const auto STATUS_PROCESS_IN_JOB             = (cast(NTSTATUS)0x00000124L);

//
// MessageId: STATUS_VOLSNAP_HIBERNATE_READY
//
// MessageText:
//
// {Volume Shadow Copy Service}
// The system is now ready for hibernation.
//
const auto STATUS_VOLSNAP_HIBERNATE_READY    = (cast(NTSTATUS)0x00000125L);

//
// MessageId: STATUS_FSFILTER_OP_COMPLETED_SUCCESSFULLY
//
// MessageText:
//
// A file system or file system filter driver has successfully completed an FsFilter operation.
//
const auto STATUS_FSFILTER_OP_COMPLETED_SUCCESSFULLY  = (cast(NTSTATUS)0x00000126L);

//
// MessageId: STATUS_INTERRUPT_VECTOR_ALREADY_CONNECTED
//
// MessageText:
//
// The specified interrupt vector was already connected.
//
const auto STATUS_INTERRUPT_VECTOR_ALREADY_CONNECTED  = (cast(NTSTATUS)0x00000127L);

//
// MessageId: STATUS_INTERRUPT_STILL_CONNECTED
//
// MessageText:
//
// The specified interrupt vector is still connected.
//
const auto STATUS_INTERRUPT_STILL_CONNECTED  = (cast(NTSTATUS)0x00000128L);

//
// MessageId: STATUS_PROCESS_CLONED
//
// MessageText:
//
// The current process is a cloned process.
//
const auto STATUS_PROCESS_CLONED             = (cast(NTSTATUS)0x00000129L);

//
// MessageId: STATUS_FILE_LOCKED_WITH_ONLY_READERS
//
// MessageText:
//
// The file was locked and all users of the file can only read.
//
const auto STATUS_FILE_LOCKED_WITH_ONLY_READERS  = (cast(NTSTATUS)0x0000012AL);

//
// MessageId: STATUS_FILE_LOCKED_WITH_WRITERS
//
// MessageText:
//
// The file was locked and at least one user of the file can write.
//
const auto STATUS_FILE_LOCKED_WITH_WRITERS   = (cast(NTSTATUS)0x0000012BL);

//
// MessageId: STATUS_RESOURCEMANAGER_READ_ONLY
//
// MessageText:
//
// The specified ResourceManager made no changes or updates to the resource under this transaction.
//
const auto STATUS_RESOURCEMANAGER_READ_ONLY  = (cast(NTSTATUS)0x00000202L);

//
// MessageId: DBG_EXCEPTION_HANDLED
//
// MessageText:
//
// Debugger handled exception
//
const auto DBG_EXCEPTION_HANDLED             = (cast(NTSTATUS)0x00010001L)    ; // winnt

//
// MessageId: DBG_CONTINUE
//
// MessageText:
//
// Debugger continued
//
const auto DBG_CONTINUE                      = (cast(NTSTATUS)0x00010002L)    ; // winnt

//
// MessageId: STATUS_FLT_IO_COMPLETE
//
// MessageText:
//
// The IO was completed by a filter.
//
const auto STATUS_FLT_IO_COMPLETE            = (cast(NTSTATUS)0x001C0001L);



/////////////////////////////////////////////////////////////////////////
//
// Standard Information values
//
/////////////////////////////////////////////////////////////////////////

//
// MessageId: STATUS_OBJECT_NAME_EXISTS
//
// MessageText:
//
// {Object Exists}
// An attempt was made to create an object and the object name already existed.
//
const auto STATUS_OBJECT_NAME_EXISTS         = (cast(NTSTATUS)0x40000000L);

//
// MessageId: STATUS_THREAD_WAS_SUSPENDED
//
// MessageText:
//
// {Thread Suspended}
// A thread termination occurred while the thread was suspended. The thread was resumed, and termination proceeded.
//
const auto STATUS_THREAD_WAS_SUSPENDED       = (cast(NTSTATUS)0x40000001L);

//
// MessageId: STATUS_WORKING_SET_LIMIT_RANGE
//
// MessageText:
//
// {Working Set Range Error}
// An attempt was made to set the working set minimum or maximum to values which are outside of the allowable range.
//
const auto STATUS_WORKING_SET_LIMIT_RANGE    = (cast(NTSTATUS)0x40000002L);

//
// MessageId: STATUS_IMAGE_NOT_AT_BASE
//
// MessageText:
//
// {Image Relocated}
// An image file could not be mapped at the address specified in the image file. Local fixups must be performed on this image.
//
const auto STATUS_IMAGE_NOT_AT_BASE          = (cast(NTSTATUS)0x40000003L);

//
// MessageId: STATUS_RXACT_STATE_CREATED
//
// MessageText:
//
// This informational level status indicates that a specified registry sub-tree transaction state did not yet exist and had to be created.
//
const auto STATUS_RXACT_STATE_CREATED        = (cast(NTSTATUS)0x40000004L);

//
// MessageId: STATUS_SEGMENT_NOTIFICATION
//
// MessageText:
//
// {Segment Load}
// A virtual DOS machine (VDM) is loading, unloading, or moving an MS-DOS or Win16 program segment image.
// An exception is raised so a debugger can load, unload or track symbols and breakpoints within these 16-bit segments.
//
const auto STATUS_SEGMENT_NOTIFICATION       = (cast(NTSTATUS)0x40000005L)    ; // winnt

//
// MessageId: STATUS_LOCAL_USER_SESSION_KEY
//
// MessageText:
//
// {Local Session Key}
// A user session key was requested for a local RPC connection. The session key returned is a constant value and not unique to this connection.
//
const auto STATUS_LOCAL_USER_SESSION_KEY     = (cast(NTSTATUS)0x40000006L);

//
// MessageId: STATUS_BAD_CURRENT_DIRECTORY
//
// MessageText:
//
// {Invalid Current Directory}
// The process cannot switch to the startup current directory %hs.
// Select OK to set current directory to %hs, or select CANCEL to exit.
//
const auto STATUS_BAD_CURRENT_DIRECTORY      = (cast(NTSTATUS)0x40000007L);

//
// MessageId: STATUS_SERIAL_MORE_WRITES
//
// MessageText:
//
// {Serial IOCTL Complete}
// A serial I/O operation was completed by another write to a serial port.
// (The IOCTL_SERIAL_XOFF_COUNTER reached zero.)
//
const auto STATUS_SERIAL_MORE_WRITES         = (cast(NTSTATUS)0x40000008L);

//
// MessageId: STATUS_REGISTRY_RECOVERED
//
// MessageText:
//
// {Registry Recovery}
// One of the files containing the system's Registry data had to be recovered by use of a log or alternate copy.
// The recovery was successful.
//
const auto STATUS_REGISTRY_RECOVERED         = (cast(NTSTATUS)0x40000009L);

//
// MessageId: STATUS_FT_READ_RECOVERY_FROM_BACKUP
//
// MessageText:
//
// {Redundant Read}
// To satisfy a read request, the NT fault-tolerant file system successfully read the requested data from a redundant copy.
// This was done because the file system encountered a failure on a member of the fault-tolerant volume, but was unable to reassign the failing area of the device.
//
const auto STATUS_FT_READ_RECOVERY_FROM_BACKUP  = (cast(NTSTATUS)0x4000000AL);

//
// MessageId: STATUS_FT_WRITE_RECOVERY
//
// MessageText:
//
// {Redundant Write}
// To satisfy a write request, the NT fault-tolerant file system successfully wrote a redundant copy of the information.
// This was done because the file system encountered a failure on a member of the fault-tolerant volume, but was not able to reassign the failing area of the device.
//
const auto STATUS_FT_WRITE_RECOVERY          = (cast(NTSTATUS)0x4000000BL);

//
// MessageId: STATUS_SERIAL_COUNTER_TIMEOUT
//
// MessageText:
//
// {Serial IOCTL Timeout}
// A serial I/O operation completed because the time-out period expired.
// (The IOCTL_SERIAL_XOFF_COUNTER had not reached zero.)
//
const auto STATUS_SERIAL_COUNTER_TIMEOUT     = (cast(NTSTATUS)0x4000000CL);

//
// MessageId: STATUS_NULL_LM_PASSWORD
//
// MessageText:
//
// {Password Too Complex}
// The Windows password is too complex to be converted to a LAN Manager password.
// The LAN Manager password returned is a NULL string.
//
const auto STATUS_NULL_LM_PASSWORD           = (cast(NTSTATUS)0x4000000DL);

//
// MessageId: STATUS_IMAGE_MACHINE_TYPE_MISMATCH
//
// MessageText:
//
// {Machine Type Mismatch}
// The image file %hs is valid, but is for a machine type other than the current machine. Select OK to continue, or CANCEL to fail the DLL load.
//
const auto STATUS_IMAGE_MACHINE_TYPE_MISMATCH  = (cast(NTSTATUS)0x4000000EL);

//
// MessageId: STATUS_RECEIVE_PARTIAL
//
// MessageText:
//
// {Partial Data Received}
// The network transport returned partial data to its client. The remaining data will be sent later.
//
const auto STATUS_RECEIVE_PARTIAL            = (cast(NTSTATUS)0x4000000FL);

//
// MessageId: STATUS_RECEIVE_EXPEDITED
//
// MessageText:
//
// {Expedited Data Received}
// The network transport returned data to its client that was marked as expedited by the remote system.
//
const auto STATUS_RECEIVE_EXPEDITED          = (cast(NTSTATUS)0x40000010L);

//
// MessageId: STATUS_RECEIVE_PARTIAL_EXPEDITED
//
// MessageText:
//
// {Partial Expedited Data Received}
// The network transport returned partial data to its client and this data was marked as expedited by the remote system. The remaining data will be sent later.
//
const auto STATUS_RECEIVE_PARTIAL_EXPEDITED  = (cast(NTSTATUS)0x40000011L);

//
// MessageId: STATUS_EVENT_DONE
//
// MessageText:
//
// {TDI Event Done}
// The TDI indication has completed successfully.
//
const auto STATUS_EVENT_DONE                 = (cast(NTSTATUS)0x40000012L);

//
// MessageId: STATUS_EVENT_PENDING
//
// MessageText:
//
// {TDI Event Pending}
// The TDI indication has entered the pending state.
//
const auto STATUS_EVENT_PENDING              = (cast(NTSTATUS)0x40000013L);

//
// MessageId: STATUS_CHECKING_FILE_SYSTEM
//
// MessageText:
//
// Checking file system on %wZ
//
const auto STATUS_CHECKING_FILE_SYSTEM       = (cast(NTSTATUS)0x40000014L);

//
// MessageId: STATUS_FATAL_APP_EXIT
//
// MessageText:
//
// {Fatal Application Exit}
// %hs
//
const auto STATUS_FATAL_APP_EXIT             = (cast(NTSTATUS)0x40000015L);

//
// MessageId: STATUS_PREDEFINED_HANDLE
//
// MessageText:
//
// The specified registry key is referenced by a predefined handle.
//
const auto STATUS_PREDEFINED_HANDLE          = (cast(NTSTATUS)0x40000016L);

//
// MessageId: STATUS_WAS_UNLOCKED
//
// MessageText:
//
// {Page Unlocked}
// The page protection of a locked page was changed to 'No Access' and the page was unlocked from memory and from the process.
//
const auto STATUS_WAS_UNLOCKED               = (cast(NTSTATUS)0x40000017L);

//
// MessageId: STATUS_SERVICE_NOTIFICATION
//
// MessageText:
//
// %hs
//
const auto STATUS_SERVICE_NOTIFICATION       = (cast(NTSTATUS)0x40000018L);

//
// MessageId: STATUS_WAS_LOCKED
//
// MessageText:
//
// {Page Locked}
// One of the pages to lock was already locked.
//
const auto STATUS_WAS_LOCKED                 = (cast(NTSTATUS)0x40000019L);

//
// MessageId: STATUS_LOG_HARD_ERROR
//
// MessageText:
//
// Application popup: %1 : %2
//
const auto STATUS_LOG_HARD_ERROR             = (cast(NTSTATUS)0x4000001AL);

//
// MessageId: STATUS_ALREADY_WIN32
//
// MessageText:
//
//  STATUS_ALREADY_WIN32
//
const auto STATUS_ALREADY_WIN32              = (cast(NTSTATUS)0x4000001BL);

//
// MessageId: STATUS_WX86_UNSIMULATE
//
// MessageText:
//
// Exception status code used by Win32 x86 emulation subsystem.
//
const auto STATUS_WX86_UNSIMULATE            = (cast(NTSTATUS)0x4000001CL);

//
// MessageId: STATUS_WX86_CONTINUE
//
// MessageText:
//
// Exception status code used by Win32 x86 emulation subsystem.
//
const auto STATUS_WX86_CONTINUE              = (cast(NTSTATUS)0x4000001DL);

//
// MessageId: STATUS_WX86_SINGLE_STEP
//
// MessageText:
//
// Exception status code used by Win32 x86 emulation subsystem.
//
const auto STATUS_WX86_SINGLE_STEP           = (cast(NTSTATUS)0x4000001EL);

//
// MessageId: STATUS_WX86_BREAKPOINT
//
// MessageText:
//
// Exception status code used by Win32 x86 emulation subsystem.
//
const auto STATUS_WX86_BREAKPOINT            = (cast(NTSTATUS)0x4000001FL);

//
// MessageId: STATUS_WX86_EXCEPTION_CONTINUE
//
// MessageText:
//
// Exception status code used by Win32 x86 emulation subsystem.
//
const auto STATUS_WX86_EXCEPTION_CONTINUE    = (cast(NTSTATUS)0x40000020L);

//
// MessageId: STATUS_WX86_EXCEPTION_LASTCHANCE
//
// MessageText:
//
// Exception status code used by Win32 x86 emulation subsystem.
//
const auto STATUS_WX86_EXCEPTION_LASTCHANCE  = (cast(NTSTATUS)0x40000021L);

//
// MessageId: STATUS_WX86_EXCEPTION_CHAIN
//
// MessageText:
//
// Exception status code used by Win32 x86 emulation subsystem.
//
const auto STATUS_WX86_EXCEPTION_CHAIN       = (cast(NTSTATUS)0x40000022L);

//
// MessageId: STATUS_IMAGE_MACHINE_TYPE_MISMATCH_EXE
//
// MessageText:
//
// {Machine Type Mismatch}
// The image file %hs is valid, but is for a machine type other than the current machine.
//
const auto STATUS_IMAGE_MACHINE_TYPE_MISMATCH_EXE  = (cast(NTSTATUS)0x40000023L);

//
// MessageId: STATUS_NO_YIELD_PERFORMED
//
// MessageText:
//
// A yield execution was performed and no thread was available to run.
//
const auto STATUS_NO_YIELD_PERFORMED         = (cast(NTSTATUS)0x40000024L);

//
// MessageId: STATUS_TIMER_RESUME_IGNORED
//
// MessageText:
//
// The resumable flag to a timer API was ignored.
//
const auto STATUS_TIMER_RESUME_IGNORED       = (cast(NTSTATUS)0x40000025L);

//
// MessageId: STATUS_ARBITRATION_UNHANDLED
//
// MessageText:
//
// The arbiter has deferred arbitration of these resources to its parent
//
const auto STATUS_ARBITRATION_UNHANDLED      = (cast(NTSTATUS)0x40000026L);

//
// MessageId: STATUS_CARDBUS_NOT_SUPPORTED
//
// MessageText:
//
// The device "%hs" has detected a CardBus card in its slot, but the firmware on this system is not configured to allow the CardBus controller to be run in CardBus mode.
// The operating system will currently accept only 16-bit (R2) pc-cards on this controller.
//
const auto STATUS_CARDBUS_NOT_SUPPORTED      = (cast(NTSTATUS)0x40000027L);

//
// MessageId: STATUS_WX86_CREATEWX86TIB
//
// MessageText:
//
// Exception status code used by Win32 x86 emulation subsystem.
//
const auto STATUS_WX86_CREATEWX86TIB         = (cast(NTSTATUS)0x40000028L);

//
// MessageId: STATUS_MP_PROCESSOR_MISMATCH
//
// MessageText:
//
// The CPUs in this multiprocessor system are not all the same revision level.  To use all processors the operating system restricts itself to the features of the least capable processor in the system.  Should problems occur with this system, contact
// the CPU manufacturer to see if this mix of processors is supported.
//
const auto STATUS_MP_PROCESSOR_MISMATCH      = (cast(NTSTATUS)0x40000029L);

//
// MessageId: STATUS_HIBERNATED
//
// MessageText:
//
// The system was put into hibernation.
//
const auto STATUS_HIBERNATED                 = (cast(NTSTATUS)0x4000002AL)    ;

//
// MessageId: STATUS_RESUME_HIBERNATION
//
// MessageText:
//
// The system was resumed from hibernation.
//
const auto STATUS_RESUME_HIBERNATION         = (cast(NTSTATUS)0x4000002BL)    ;

//
// MessageId: STATUS_FIRMWARE_UPDATED
//
// MessageText:
//
// Windows has detected that the system firmware (BIOS) was updated [previous firmware date = %2, current firmware date %3].
//
const auto STATUS_FIRMWARE_UPDATED           = (cast(NTSTATUS)0x4000002CL);

//
// MessageId: STATUS_DRIVERS_LEAKING_LOCKED_PAGES
//
// MessageText:
//
// A device driver is leaking locked I/O pages causing system degradation.  The system has automatically enabled tracking code in order to try and catch the culprit.
//
const auto STATUS_DRIVERS_LEAKING_LOCKED_PAGES  = (cast(NTSTATUS)0x4000002DL);

//
// MessageId: STATUS_MESSAGE_RETRIEVED
//
// MessageText:
//
// The ALPC message being canceled has already been retrieved from the queue on the other side.
//
const auto STATUS_MESSAGE_RETRIEVED          = (cast(NTSTATUS)0x4000002EL);

//
// MessageId: STATUS_SYSTEM_POWERSTATE_TRANSITION
//
// MessageText:
//
// The system powerstate is transitioning from %2 to %3.
//
const auto STATUS_SYSTEM_POWERSTATE_TRANSITION  = (cast(NTSTATUS)0x4000002FL)    ;

//
// MessageId: STATUS_ALPC_CHECK_COMPLETION_LIST
//
// MessageText:
//
// The receive operation was successful. Check the ALPC completion list for the received message.
//
const auto STATUS_ALPC_CHECK_COMPLETION_LIST  = (cast(NTSTATUS)0x40000030L);

//
// MessageId: STATUS_SYSTEM_POWERSTATE_COMPLEX_TRANSITION
//
// MessageText:
//
// The system powerstate is transitioning from %2 to %3 but could enter %4.
//
const auto STATUS_SYSTEM_POWERSTATE_COMPLEX_TRANSITION  = (cast(NTSTATUS)0x40000031L)    ;

//
// MessageId: STATUS_ACCESS_AUDIT_BY_POLICY
//
// MessageText:
//
// Access to %1 is monitored by policy rule %2.
//
const auto STATUS_ACCESS_AUDIT_BY_POLICY     = (cast(NTSTATUS)0x40000032L)    ;

//
// MessageId: STATUS_ABANDON_HIBERFILE
//
// MessageText:
//
// A valid hibernation file has been invalidated and should be abandoned.
//
const auto STATUS_ABANDON_HIBERFILE          = (cast(NTSTATUS)0x40000033L);

//
// MessageId: STATUS_BIZRULES_NOT_ENABLED
//
// MessageText:
//
// Business rule scripts are disabled for the calling application.
//
const auto STATUS_BIZRULES_NOT_ENABLED       = (cast(NTSTATUS)0x40000034L);

//
// MessageId: DBG_REPLY_LATER
//
// MessageText:
//
// Debugger will reply later.
//
const auto DBG_REPLY_LATER                   = (cast(NTSTATUS)0x40010001L);

//
// MessageId: DBG_UNABLE_TO_PROVIDE_HANDLE
//
// MessageText:
//
// Debugger cannot provide handle.
//
const auto DBG_UNABLE_TO_PROVIDE_HANDLE      = (cast(NTSTATUS)0x40010002L);

//
// MessageId: DBG_TERMINATE_THREAD
//
// MessageText:
//
// Debugger terminated thread.
//
const auto DBG_TERMINATE_THREAD              = (cast(NTSTATUS)0x40010003L)    ; // winnt

//
// MessageId: DBG_TERMINATE_PROCESS
//
// MessageText:
//
// Debugger terminated process.
//
const auto DBG_TERMINATE_PROCESS             = (cast(NTSTATUS)0x40010004L)    ; // winnt

//
// MessageId: DBG_CONTROL_C
//
// MessageText:
//
// Debugger got control C.
//
const auto DBG_CONTROL_C                     = (cast(NTSTATUS)0x40010005L)    ; // winnt

//
// MessageId: DBG_PRINTEXCEPTION_C
//
// MessageText:
//
// Debugger printed exception on control C.
//
const auto DBG_PRINTEXCEPTION_C              = (cast(NTSTATUS)0x40010006L);

//
// MessageId: DBG_RIPEXCEPTION
//
// MessageText:
//
// Debugger received RIP exception.
//
const auto DBG_RIPEXCEPTION                  = (cast(NTSTATUS)0x40010007L);

//
// MessageId: DBG_CONTROL_BREAK
//
// MessageText:
//
// Debugger received control break.
//
const auto DBG_CONTROL_BREAK                 = (cast(NTSTATUS)0x40010008L)    ; // winnt

//
// MessageId: DBG_COMMAND_EXCEPTION
//
// MessageText:
//
// Debugger command communication exception.
//
const auto DBG_COMMAND_EXCEPTION             = (cast(NTSTATUS)0x40010009L)    ; // winnt

//
// MessageId: STATUS_FLT_BUFFER_TOO_SMALL
//
// MessageText:
//
// {Buffer too small}
// The buffer is too small to contain the entry. No information has been written to the buffer.
//
const auto STATUS_FLT_BUFFER_TOO_SMALL       = (cast(NTSTATUS)0x801C0001L);



/////////////////////////////////////////////////////////////////////////
//
// Standard Warning values
//
//
// Note:  Do NOT use the value 0x80000000L, as this is a non-portable value
//        for the NT_SUCCESS macro. Warning values start with a code of 1.
//
/////////////////////////////////////////////////////////////////////////

//
// MessageId: STATUS_GUARD_PAGE_VIOLATION
//
// MessageText:
//
// {EXCEPTION}
// Guard Page Exception
// A page of memory that marks the end of a data structure, such as a stack or an array, has been accessed.
//
//const auto STATUS_GUARD_PAGE_VIOLATION       = (cast(NTSTATUS)0x80000001L)    ; // winnt

//
// MessageId: STATUS_DATATYPE_MISALIGNMENT
//
// MessageText:
//
// {EXCEPTION}
// Alignment Fault
// A datatype misalignment was detected in a load or store instruction.
//
//const auto STATUS_DATATYPE_MISALIGNMENT      = (cast(NTSTATUS)0x80000002L)    ; // winnt

//
// MessageId: STATUS_BREAKPOINT
//
// MessageText:
//
// {EXCEPTION}
// Breakpoint
// A breakpoint has been reached.
//
//const auto STATUS_BREAKPOINT                 = (cast(NTSTATUS)0x80000003L)    ; // winnt

//
// MessageId: STATUS_SINGLE_STEP
//
// MessageText:
//
// {EXCEPTION}
// Single Step
// A single step or trace operation has just been completed.
//
//const auto STATUS_SINGLE_STEP                = (cast(NTSTATUS)0x80000004L)    ; // winnt

//
// MessageId: STATUS_BUFFER_OVERFLOW
//
// MessageText:
//
// {Buffer Overflow}
// The data was too large to fit into the specified buffer.
//
const auto STATUS_BUFFER_OVERFLOW            = (cast(NTSTATUS)0x80000005L);

//
// MessageId: STATUS_NO_MORE_FILES
//
// MessageText:
//
// {No More Files}
// No more files were found which match the file specification.
//
const auto STATUS_NO_MORE_FILES              = (cast(NTSTATUS)0x80000006L);

//
// MessageId: STATUS_WAKE_SYSTEM_DEBUGGER
//
// MessageText:
//
// {Kernel Debugger Awakened}
// the system debugger was awakened by an interrupt.
//
const auto STATUS_WAKE_SYSTEM_DEBUGGER       = (cast(NTSTATUS)0x80000007L);

//
// MessageId: STATUS_HANDLES_CLOSED
//
// MessageText:
//
// {Handles Closed}
// Handles to objects have been automatically closed as a result of the requested operation.
//
const auto STATUS_HANDLES_CLOSED             = (cast(NTSTATUS)0x8000000AL);

//
// MessageId: STATUS_NO_INHERITANCE
//
// MessageText:
//
// {Non-Inheritable ACL}
// An access control list (ACL) contains no components that can be inherited.
//
const auto STATUS_NO_INHERITANCE             = (cast(NTSTATUS)0x8000000BL);

//
// MessageId: STATUS_GUID_SUBSTITUTION_MADE
//
// MessageText:
//
// {GUID Substitution}
// During the translation of a global identifier (GUID) to a Windows security ID (SID), no administratively-defined GUID prefix was found.
// A substitute prefix was used, which will not compromise system security.
// However, this may provide a more restrictive access than intended.
//
const auto STATUS_GUID_SUBSTITUTION_MADE     = (cast(NTSTATUS)0x8000000CL);

//
// MessageId: STATUS_PARTIAL_COPY
//
// MessageText:
//
// {Partial Copy}
// Due to protection conflicts not all the requested bytes could be copied.
//
const auto STATUS_PARTIAL_COPY               = (cast(NTSTATUS)0x8000000DL);

//
// MessageId: STATUS_DEVICE_PAPER_EMPTY
//
// MessageText:
//
// {Out of Paper}
// The printer is out of paper.
//
const auto STATUS_DEVICE_PAPER_EMPTY         = (cast(NTSTATUS)0x8000000EL);

//
// MessageId: STATUS_DEVICE_POWERED_OFF
//
// MessageText:
//
// {Device Power Is Off}
// The printer power has been turned off.
//
const auto STATUS_DEVICE_POWERED_OFF         = (cast(NTSTATUS)0x8000000FL);

//
// MessageId: STATUS_DEVICE_OFF_LINE
//
// MessageText:
//
// {Device Offline}
// The printer has been taken offline.
//
const auto STATUS_DEVICE_OFF_LINE            = (cast(NTSTATUS)0x80000010L);

//
// MessageId: STATUS_DEVICE_BUSY
//
// MessageText:
//
// {Device Busy}
// The device is currently busy.
//
const auto STATUS_DEVICE_BUSY                = (cast(NTSTATUS)0x80000011L);

//
// MessageId: STATUS_NO_MORE_EAS
//
// MessageText:
//
// {No More EAs}
// No more extended attributes (EAs) were found for the file.
//
const auto STATUS_NO_MORE_EAS                = (cast(NTSTATUS)0x80000012L);

//
// MessageId: STATUS_INVALID_EA_NAME
//
// MessageText:
//
// {Illegal EA}
// The specified extended attribute (EA) name contains at least one illegal character.
//
const auto STATUS_INVALID_EA_NAME            = (cast(NTSTATUS)0x80000013L);

//
// MessageId: STATUS_EA_LIST_INCONSISTENT
//
// MessageText:
//
// {Inconsistent EA List}
// The extended attribute (EA) list is inconsistent.
//
const auto STATUS_EA_LIST_INCONSISTENT       = (cast(NTSTATUS)0x80000014L);

//
// MessageId: STATUS_INVALID_EA_FLAG
//
// MessageText:
//
// {Invalid EA Flag}
// An invalid extended attribute (EA) flag was set.
//
const auto STATUS_INVALID_EA_FLAG            = (cast(NTSTATUS)0x80000015L);

//
// MessageId: STATUS_VERIFY_REQUIRED
//
// MessageText:
//
// {Verifying Disk}
// The media has changed and a verify operation is in progress so no reads or writes may be performed to the device, except those used in the verify operation.
//
const auto STATUS_VERIFY_REQUIRED            = (cast(NTSTATUS)0x80000016L);

//
// MessageId: STATUS_EXTRANEOUS_INFORMATION
//
// MessageText:
//
// {Too Much Information}
// The specified access control list (ACL) contained more information than was expected.
//
const auto STATUS_EXTRANEOUS_INFORMATION     = (cast(NTSTATUS)0x80000017L);

//
// MessageId: STATUS_RXACT_COMMIT_NECESSARY
//
// MessageText:
//
// This warning level status indicates that the transaction state already exists for the registry sub-tree, but that a transaction commit was previously aborted.
// The commit has NOT been completed, but has not been rolled back either (so it may still be committed if desired).
//
const auto STATUS_RXACT_COMMIT_NECESSARY     = (cast(NTSTATUS)0x80000018L);

//
// MessageId: STATUS_NO_MORE_ENTRIES
//
// MessageText:
//
// {No More Entries}
// No more entries are available from an enumeration operation.
//
const auto STATUS_NO_MORE_ENTRIES            = (cast(NTSTATUS)0x8000001AL);

//
// MessageId: STATUS_FILEMARK_DETECTED
//
// MessageText:
//
// {Filemark Found}
// A filemark was detected.
//
const auto STATUS_FILEMARK_DETECTED          = (cast(NTSTATUS)0x8000001BL);

//
// MessageId: STATUS_MEDIA_CHANGED
//
// MessageText:
//
// {Media Changed}
// The media may have changed.
//
const auto STATUS_MEDIA_CHANGED              = (cast(NTSTATUS)0x8000001CL);

//
// MessageId: STATUS_BUS_RESET
//
// MessageText:
//
// {I/O Bus Reset}
// An I/O bus reset was detected.
//
const auto STATUS_BUS_RESET                  = (cast(NTSTATUS)0x8000001DL);

//
// MessageId: STATUS_END_OF_MEDIA
//
// MessageText:
//
// {End of Media}
// The end of the media was encountered.
//
const auto STATUS_END_OF_MEDIA               = (cast(NTSTATUS)0x8000001EL);

//
// MessageId: STATUS_BEGINNING_OF_MEDIA
//
// MessageText:
//
// Beginning of tape or partition has been detected.
//
const auto STATUS_BEGINNING_OF_MEDIA         = (cast(NTSTATUS)0x8000001FL);

//
// MessageId: STATUS_MEDIA_CHECK
//
// MessageText:
//
// {Media Changed}
// The media may have changed.
//
const auto STATUS_MEDIA_CHECK                = (cast(NTSTATUS)0x80000020L);

//
// MessageId: STATUS_SETMARK_DETECTED
//
// MessageText:
//
// A tape access reached a setmark.
//
const auto STATUS_SETMARK_DETECTED           = (cast(NTSTATUS)0x80000021L);

//
// MessageId: STATUS_NO_DATA_DETECTED
//
// MessageText:
//
// During a tape access, the end of the data written is reached.
//
const auto STATUS_NO_DATA_DETECTED           = (cast(NTSTATUS)0x80000022L);

//
// MessageId: STATUS_REDIRECTOR_HAS_OPEN_HANDLES
//
// MessageText:
//
// The redirector is in use and cannot be unloaded.
//
const auto STATUS_REDIRECTOR_HAS_OPEN_HANDLES  = (cast(NTSTATUS)0x80000023L);

//
// MessageId: STATUS_SERVER_HAS_OPEN_HANDLES
//
// MessageText:
//
// The server is in use and cannot be unloaded.
//
const auto STATUS_SERVER_HAS_OPEN_HANDLES    = (cast(NTSTATUS)0x80000024L);

//
// MessageId: STATUS_ALREADY_DISCONNECTED
//
// MessageText:
//
// The specified connection has already been disconnected.
//
const auto STATUS_ALREADY_DISCONNECTED       = (cast(NTSTATUS)0x80000025L);

//
// MessageId: STATUS_LONGJUMP
//
// MessageText:
//
// A long jump has been executed.
//
const auto STATUS_LONGJUMP                   = (cast(NTSTATUS)0x80000026L);

//
// MessageId: STATUS_CLEANER_CARTRIDGE_INSTALLED
//
// MessageText:
//
// A cleaner cartridge is present in the tape library.
//
const auto STATUS_CLEANER_CARTRIDGE_INSTALLED  = (cast(NTSTATUS)0x80000027L);

//
// MessageId: STATUS_PLUGPLAY_QUERY_VETOED
//
// MessageText:
//
// The Plug and Play query operation was not successful.
//
const auto STATUS_PLUGPLAY_QUERY_VETOED      = (cast(NTSTATUS)0x80000028L);

//
// MessageId: STATUS_UNWIND_CONSOLIDATE
//
// MessageText:
//
// A frame consolidation has been executed.
//
const auto STATUS_UNWIND_CONSOLIDATE         = (cast(NTSTATUS)0x80000029L);

//
// MessageId: STATUS_REGISTRY_HIVE_RECOVERED
//
// MessageText:
//
// {Registry Hive Recovered}
// Registry hive (file):
// %hs
// was corrupted and it has been recovered. Some data might have been lost.
//
const auto STATUS_REGISTRY_HIVE_RECOVERED    = (cast(NTSTATUS)0x8000002AL);

//
// MessageId: STATUS_DLL_MIGHT_BE_INSECURE
//
// MessageText:
//
// The application is attempting to run executable code from the module %hs.  This may be insecure.  An alternative, %hs, is available.  Should the application use the secure module %hs?
//
const auto STATUS_DLL_MIGHT_BE_INSECURE      = (cast(NTSTATUS)0x8000002BL);

//
// MessageId: STATUS_DLL_MIGHT_BE_INCOMPATIBLE
//
// MessageText:
//
// The application is loading executable code from the module %hs.  This is secure, but may be incompatible with previous releases of the operating system.  An alternative, %hs, is available.  Should the application use the secure module %hs?
//
const auto STATUS_DLL_MIGHT_BE_INCOMPATIBLE  = (cast(NTSTATUS)0x8000002CL);

//
// MessageId: STATUS_STOPPED_ON_SYMLINK
//
// MessageText:
//
// The create operation stopped after reaching a symbolic link.
//
const auto STATUS_STOPPED_ON_SYMLINK         = (cast(NTSTATUS)0x8000002DL);

//
// MessageId: DBG_EXCEPTION_NOT_HANDLED
//
// MessageText:
//
// Debugger did not handle the exception.
//
const auto DBG_EXCEPTION_NOT_HANDLED         = (cast(NTSTATUS)0x80010001L)    ; // winnt

//
// MessageId: STATUS_CLUSTER_NODE_ALREADY_UP
//
// MessageText:
//
// The cluster node is already up.
//
const auto STATUS_CLUSTER_NODE_ALREADY_UP    = (cast(NTSTATUS)0x80130001L);

//
// MessageId: STATUS_CLUSTER_NODE_ALREADY_DOWN
//
// MessageText:
//
// The cluster node is already down.
//
const auto STATUS_CLUSTER_NODE_ALREADY_DOWN  = (cast(NTSTATUS)0x80130002L);

//
// MessageId: STATUS_CLUSTER_NETWORK_ALREADY_ONLINE
//
// MessageText:
//
// The cluster network is already online.
//
const auto STATUS_CLUSTER_NETWORK_ALREADY_ONLINE  = (cast(NTSTATUS)0x80130003L);

//
// MessageId: STATUS_CLUSTER_NETWORK_ALREADY_OFFLINE
//
// MessageText:
//
// The cluster network is already offline.
//
const auto STATUS_CLUSTER_NETWORK_ALREADY_OFFLINE  = (cast(NTSTATUS)0x80130004L);

//
// MessageId: STATUS_CLUSTER_NODE_ALREADY_MEMBER
//
// MessageText:
//
// The cluster node is already a member of the cluster.
//
const auto STATUS_CLUSTER_NODE_ALREADY_MEMBER  = (cast(NTSTATUS)0x80130005L);

//
// MessageId: STATUS_FVE_PARTIAL_METADATA
//
// MessageText:
//
// Volume Metadata read or write is incomplete.
//
const auto STATUS_FVE_PARTIAL_METADATA       = (cast(NTSTATUS)0x80210001L);



/////////////////////////////////////////////////////////////////////////
//
//  Standard Error values
//
/////////////////////////////////////////////////////////////////////////

//
// MessageId: STATUS_UNSUCCESSFUL
//
// MessageText:
//
// {Operation Failed}
// The requested operation was unsuccessful.
//
const auto STATUS_UNSUCCESSFUL               = (cast(NTSTATUS)0xC0000001L);

//
// MessageId: STATUS_NOT_IMPLEMENTED
//
// MessageText:
//
// {Not Implemented}
// The requested operation is not implemented.
//
const auto STATUS_NOT_IMPLEMENTED            = (cast(NTSTATUS)0xC0000002L);

//
// MessageId: STATUS_INVALID_INFO_CLASS
//
// MessageText:
//
// {Invalid Parameter}
// The specified information class is not a valid information class for the specified object.
//
const auto STATUS_INVALID_INFO_CLASS         = (cast(NTSTATUS)0xC0000003L)    ; // ntsubauth

//
// MessageId: STATUS_INFO_LENGTH_MISMATCH
//
// MessageText:
//
// The specified information record length does not match the length required for the specified information class.
//
const auto STATUS_INFO_LENGTH_MISMATCH       = (cast(NTSTATUS)0xC0000004L);

//
// MessageId: STATUS_ACCESS_VIOLATION
//
// MessageText:
//
// The instruction at 0x%08lx referenced memory at 0x%08lx. The memory could not be %s.
//
//const auto STATUS_ACCESS_VIOLATION           = (cast(NTSTATUS)0xC0000005L)    ; // winnt

//
// MessageId: STATUS_IN_PAGE_ERROR
//
// MessageText:
//
// The instruction at 0x%08lx referenced memory at 0x%08lx. The required data was not placed into memory because of an I/O error status of 0x%08lx.
//
//const auto STATUS_IN_PAGE_ERROR              = (cast(NTSTATUS)0xC0000006L)    ; // winnt

//
// MessageId: STATUS_PAGEFILE_QUOTA
//
// MessageText:
//
// The pagefile quota for the process has been exhausted.
//
const auto STATUS_PAGEFILE_QUOTA             = (cast(NTSTATUS)0xC0000007L);

//
// MessageId: STATUS_INVALID_HANDLE
//
// MessageText:
//
// An invalid HANDLE was specified.
//
//const auto STATUS_INVALID_HANDLE             = (cast(NTSTATUS)0xC0000008L)    ; // winnt

//
// MessageId: STATUS_BAD_INITIAL_STACK
//
// MessageText:
//
// An invalid initial stack was specified in a call to NtCreateThread.
//
const auto STATUS_BAD_INITIAL_STACK          = (cast(NTSTATUS)0xC0000009L);

//
// MessageId: STATUS_BAD_INITIAL_PC
//
// MessageText:
//
// An invalid initial start address was specified in a call to NtCreateThread.
//
const auto STATUS_BAD_INITIAL_PC             = (cast(NTSTATUS)0xC000000AL);

//
// MessageId: STATUS_INVALID_CID
//
// MessageText:
//
// An invalid Client ID was specified.
//
const auto STATUS_INVALID_CID                = (cast(NTSTATUS)0xC000000BL);

//
// MessageId: STATUS_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 STATUS_TIMER_NOT_CANCELED         = (cast(NTSTATUS)0xC000000CL);

//
// MessageId: STATUS_INVALID_PARAMETER
//
// MessageText:
//
// An invalid parameter was passed to a service or function.
//
const auto STATUS_INVALID_PARAMETER          = (cast(NTSTATUS)0xC000000DL);

//
// MessageId: STATUS_NO_SUCH_DEVICE
//
// MessageText:
//
// A device which does not exist was specified.
//
const auto STATUS_NO_SUCH_DEVICE             = (cast(NTSTATUS)0xC000000EL);

//
// MessageId: STATUS_NO_SUCH_FILE
//
// MessageText:
//
// {File Not Found}
// The file %hs does not exist.
//
const auto STATUS_NO_SUCH_FILE               = (cast(NTSTATUS)0xC000000FL);

//
// MessageId: STATUS_INVALID_DEVICE_REQUEST
//
// MessageText:
//
// The specified request is not a valid operation for the target device.
//
const auto STATUS_INVALID_DEVICE_REQUEST     = (cast(NTSTATUS)0xC0000010L);

//
// MessageId: STATUS_END_OF_FILE
//
// MessageText:
//
// The end-of-file marker has been reached. There is no valid data in the file beyond this marker.
//
const auto STATUS_END_OF_FILE                = (cast(NTSTATUS)0xC0000011L);

//
// MessageId: STATUS_WRONG_VOLUME
//
// MessageText:
//
// {Wrong Volume}
// The wrong volume is in the drive.
// Please insert volume %hs into drive %hs.
//
const auto STATUS_WRONG_VOLUME               = (cast(NTSTATUS)0xC0000012L);

//
// MessageId: STATUS_NO_MEDIA_IN_DEVICE
//
// MessageText:
//
// {No Disk}
// There is no disk in the drive.
// Please insert a disk into drive %hs.
//
const auto STATUS_NO_MEDIA_IN_DEVICE         = (cast(NTSTATUS)0xC0000013L);

//
// MessageId: STATUS_UNRECOGNIZED_MEDIA
//
// MessageText:
//
// {Unknown Disk Format}
// The disk in drive %hs is not formatted properly.
// Please check the disk, and reformat if necessary.
//
const auto STATUS_UNRECOGNIZED_MEDIA         = (cast(NTSTATUS)0xC0000014L);

//
// MessageId: STATUS_NONEXISTENT_SECTOR
//
// MessageText:
//
// {Sector Not Found}
// The specified sector does not exist.
//
const auto STATUS_NONEXISTENT_SECTOR         = (cast(NTSTATUS)0xC0000015L);

//
// MessageId: STATUS_MORE_PROCESSING_REQUIRED
//
// MessageText:
//
// {Still Busy}
// The specified I/O request packet (IRP) cannot be disposed of because the I/O operation is not complete.
//
const auto STATUS_MORE_PROCESSING_REQUIRED   = (cast(NTSTATUS)0xC0000016L);

//
// MessageId: STATUS_NO_MEMORY
//
// MessageText:
//
// {Not Enough Quota}
// Not enough virtual memory or paging file quota is available to complete the specified operation.
//
const auto STATUS_NO_MEMORY                  = (cast(NTSTATUS)0xC0000017L)    ; // winnt

//
// MessageId: STATUS_CONFLICTING_ADDRESSES
//
// MessageText:
//
// {Conflicting Address Range}
// The specified address range conflicts with the address space.
//
const auto STATUS_CONFLICTING_ADDRESSES      = (cast(NTSTATUS)0xC0000018L);

//
// MessageId: STATUS_NOT_MAPPED_VIEW
//
// MessageText:
//
// Address range to unmap is not a mapped view.
//
const auto STATUS_NOT_MAPPED_VIEW            = (cast(NTSTATUS)0xC0000019L);

//
// MessageId: STATUS_UNABLE_TO_FREE_VM
//
// MessageText:
//
// Virtual memory cannot be freed.
//
const auto STATUS_UNABLE_TO_FREE_VM          = (cast(NTSTATUS)0xC000001AL);

//
// MessageId: STATUS_UNABLE_TO_DELETE_SECTION
//
// MessageText:
//
// Specified section cannot be deleted.
//
const auto STATUS_UNABLE_TO_DELETE_SECTION   = (cast(NTSTATUS)0xC000001BL);

//
// MessageId: STATUS_INVALID_SYSTEM_SERVICE
//
// MessageText:
//
// An invalid system service was specified in a system service call.
//
const auto STATUS_INVALID_SYSTEM_SERVICE     = (cast(NTSTATUS)0xC000001CL);

//
// MessageId: STATUS_ILLEGAL_INSTRUCTION
//
// MessageText:
//
// {EXCEPTION}
// Illegal Instruction
// An attempt was made to execute an illegal instruction.
//
//const auto STATUS_ILLEGAL_INSTRUCTION        = (cast(NTSTATUS)0xC000001DL)    ; // winnt

//
// MessageId: STATUS_INVALID_LOCK_SEQUENCE
//
// MessageText:
//
// {Invalid Lock Sequence}
// An attempt was made to execute an invalid lock sequence.
//
const auto STATUS_INVALID_LOCK_SEQUENCE      = (cast(NTSTATUS)0xC000001EL);

//
// MessageId: STATUS_INVALID_VIEW_SIZE
//
// MessageText:
//
// {Invalid Mapping}
// An attempt was made to create a view for a section which is bigger than the section.
//
const auto STATUS_INVALID_VIEW_SIZE          = (cast(NTSTATUS)0xC000001FL);

//
// MessageId: STATUS_INVALID_FILE_FOR_SECTION
//
// MessageText:
//
// {Bad File}
// The attributes of the specified mapping file for a section of memory cannot be read.
//
const auto STATUS_INVALID_FILE_FOR_SECTION   = (cast(NTSTATUS)0xC0000020L);

//
// MessageId: STATUS_ALREADY_COMMITTED…