/**
 * Windows API header module
 *
 * Translated from MinGW API for MS-Windows 3.10
 *
 * License: $(LINK2 http://www.boost.org/LICENSE_1_0.txt, Boost License 1.0)
 * Source: $(DRUNTIMESRC core/sys/windows/_winbase.d)
 */
module core.sys.windows.winbase;
version (Windows):

version (ANSI) {} else version = Unicode;
pragma(lib, "kernel32");

/**
Translation Notes:
The following macros are obsolete, and have no effect.

LockSegment(w), MakeProcInstance(p, i), UnlockResource(h), UnlockSegment(w)
FreeModule(m), FreeProcInstance(p), GetFreeSpace(w), DefineHandleTable(w)
SetSwapAreaSize(w), LimitEmsPages(n), Yield()

// These are not required for DMD.

//FIXME:
// #ifndef UNDER_CE
    int WinMain(HINSTANCE, HINSTANCE, LPSTR, int);
#else
    int WinMain(HINSTANCE, HINSTANCE, LPWSTR, int);
#endif
int wWinMain(HINSTANCE, HINSTANCE, LPWSTR, int);

*/

import core.sys.windows.windef, core.sys.windows.winver;
import core.sys.windows.basetyps, core.sys.windows.w32api, core.sys.windows.winnt;

// FIXME:
//alias void va_list;
import core.stdc.stdarg : va_list;
import core.stdc.string : memset, memcpy, memmove;


// COMMPROP structure, used by GetCommProperties()
// -----------------------------------------------

// Communications provider type
enum : DWORD {
    PST_UNSPECIFIED,
    PST_RS232,
    PST_PARALLELPORT,
    PST_RS422,
    PST_RS423,
    PST_RS449,
    PST_MODEM,      // =      6
    PST_FAX            = 0x0021,
    PST_SCANNER        = 0x0022,
    PST_NETWORK_BRIDGE = 0x0100,
    PST_LAT            = 0x0101,
    PST_TCPIP_TELNET   = 0x0102,
    PST_X25            = 0x0103
}

// Max baud rate
enum : DWORD {
    BAUD_075    = 0x00000001,
    BAUD_110    = 0x00000002,
    BAUD_134_5  = 0x00000004,
    BAUD_150    = 0x00000008,
    BAUD_300    = 0x00000010,
    BAUD_600    = 0x00000020,
    BAUD_1200   = 0x00000040,
    BAUD_1800   = 0x00000080,
    BAUD_2400   = 0x00000100,
    BAUD_4800   = 0x00000200,
    BAUD_7200   = 0x00000400,
    BAUD_9600   = 0x00000800,
    BAUD_14400  = 0x00001000,
    BAUD_19200  = 0x00002000,
    BAUD_38400  = 0x00004000,
    BAUD_56K    = 0x00008000,
    BAUD_128K   = 0x00010000,
    BAUD_115200 = 0x00020000,
    BAUD_57600  = 0x00040000,
    BAUD_USER   = 0x10000000
}

// Comm capabilities
enum : DWORD {
    PCF_DTRDSR        = 0x0001,
    PCF_RTSCTS        = 0x0002,
    PCF_RLSD          = 0x0004,
    PCF_PARITY_CHECK  = 0x0008,
    PCF_XONXOFF       = 0x0010,
    PCF_SETXCHAR      = 0x0020,
    PCF_TOTALTIMEOUTS = 0x0040,
    PCF_INTTIMEOUTS   = 0x0080,
    PCF_SPECIALCHARS  = 0x0100,
    PCF_16BITMODE     = 0x0200
}

enum  : DWORD {
    SP_PARITY       = 1,
    SP_BAUD         = 2,
    SP_DATABITS     = 4,
    SP_STOPBITS     = 8,
    SP_HANDSHAKING  = 16,
    SP_PARITY_CHECK = 32,
    SP_RLSD         = 64
}

enum : DWORD {
    DATABITS_5   = 1,
    DATABITS_6   = 2,
    DATABITS_7   = 4,
    DATABITS_8   = 8,
    DATABITS_16  = 16,
    DATABITS_16X = 32
}

enum : WORD {
    STOPBITS_10  = 0x0001,
    STOPBITS_15  = 0x0002,
    STOPBITS_20  = 0x0004,
    PARITY_NONE  = 0x0100,
    PARITY_ODD   = 0x0200,
    PARITY_EVEN  = 0x0400,
    PARITY_MARK  = 0x0800,
    PARITY_SPACE = 0x1000
}

// used by dwServiceMask
enum SP_SERIALCOMM = 1;

struct COMMPROP {
    WORD  wPacketLength;
    WORD  wPacketVersion;
    DWORD dwServiceMask;
    DWORD dwReserved1;
    DWORD dwMaxTxQueue;
    DWORD dwMaxRxQueue;
    DWORD dwMaxBaud;
    DWORD dwProvSubType;
    DWORD dwProvCapabilities;
    DWORD dwSettableParams;
    DWORD dwSettableBaud;
    WORD  wSettableData;
    WORD  wSettableStopParity;
    DWORD dwCurrentTxQueue;
    DWORD dwCurrentRxQueue;
    DWORD dwProvSpec1;
    DWORD dwProvSpec2;
    WCHAR _wcProvChar = 0;

    WCHAR* wcProvChar() return { return &_wcProvChar; }
}
alias LPCOMMPROP = COMMPROP*;

// ----------

// for DEBUG_EVENT
enum : DWORD {
    EXCEPTION_DEBUG_EVENT = 1,
    CREATE_THREAD_DEBUG_EVENT,
    CREATE_PROCESS_DEBUG_EVENT,
    EXIT_THREAD_DEBUG_EVENT,
    EXIT_PROCESS_DEBUG_EVENT,
    LOAD_DLL_DEBUG_EVENT,
    UNLOAD_DLL_DEBUG_EVENT,
    OUTPUT_DEBUG_STRING_EVENT,
    RIP_EVENT
}

enum HFILE HFILE_ERROR = cast(HFILE) (-1);

// for SetFilePointer()
enum : DWORD {
    FILE_BEGIN   = 0,
    FILE_CURRENT = 1,
    FILE_END     = 2
}
enum DWORD INVALID_SET_FILE_POINTER = -1;


// for OpenFile()
deprecated enum : UINT {
    OF_READ             = 0,
    OF_WRITE            = 0x0001,
    OF_READWRITE        = 0x0002,
    OF_SHARE_COMPAT     = 0,
    OF_SHARE_EXCLUSIVE  = 0x0010,
    OF_SHARE_DENY_WRITE = 0x0020,
    OF_SHARE_DENY_READ  = 0x0030,
    OF_SHARE_DENY_NONE  = 0x0040,
    OF_PARSE            = 0x0100,
    OF_DELETE           = 0x0200,
    OF_VERIFY           = 0x0400,
    OF_CANCEL           = 0x0800,
    OF_CREATE           = 0x1000,
    OF_PROMPT           = 0x2000,
    OF_EXIST            = 0x4000,
    OF_REOPEN           = 0x8000
}

enum : DWORD {
    NMPWAIT_NOWAIT           =  1,
    NMPWAIT_WAIT_FOREVER     = -1,
    NMPWAIT_USE_DEFAULT_WAIT =  0
}

// for ClearCommError()
enum DWORD
    CE_RXOVER   = 0x0001,
    CE_OVERRUN  = 0x0002,
    CE_RXPARITY = 0x0004,
    CE_FRAME    = 0x0008,
    CE_BREAK    = 0x0010,
    CE_TXFULL   = 0x0100,
    CE_PTO      = 0x0200,
    CE_IOE      = 0x0400,
    CE_DNS      = 0x0800,
    CE_OOP      = 0x1000,
    CE_MODE     = 0x8000;

// for CopyProgressRoutine callback.
enum : DWORD {
    PROGRESS_CONTINUE = 0,
    PROGRESS_CANCEL   = 1,
    PROGRESS_STOP     = 2,
    PROGRESS_QUIET    = 3
}

enum : DWORD {
    CALLBACK_CHUNK_FINISHED = 0,
    CALLBACK_STREAM_SWITCH  = 1
}

// CopyFileEx()
enum : DWORD {
    COPY_FILE_FAIL_IF_EXISTS = 1,
    COPY_FILE_RESTARTABLE    = 2
}

enum : DWORD {
    FILE_MAP_COPY       = 1,
    FILE_MAP_WRITE      = 2,
    FILE_MAP_READ       = 4,
    FILE_MAP_ALL_ACCESS = 0x000F001F
}

enum : DWORD {
    MUTEX_ALL_ACCESS       = 0x001f0001,
    MUTEX_MODIFY_STATE     = 0x00000001,
    SEMAPHORE_ALL_ACCESS   = 0x001f0003,
    SEMAPHORE_MODIFY_STATE = 0x00000002,
    EVENT_ALL_ACCESS       = 0x001f0003,
    EVENT_MODIFY_STATE     = 0x00000002
}

// CreateNamedPipe()
enum : DWORD {
    PIPE_ACCESS_INBOUND  = 1,
    PIPE_ACCESS_OUTBOUND = 2,
    PIPE_ACCESS_DUPLEX   = 3
}

enum DWORD
    PIPE_TYPE_BYTE        = 0,
    PIPE_TYPE_MESSAGE     = 4,
    PIPE_READMODE_BYTE    = 0,
    PIPE_READMODE_MESSAGE = 2,
    PIPE_WAIT             = 0,
    PIPE_NOWAIT           = 1;

// GetNamedPipeInfo()
enum DWORD
    PIPE_CLIENT_END  = 0,
    PIPE_SERVER_END  = 1;

enum DWORD PIPE_UNLIMITED_INSTANCES = 255;

// dwCreationFlags for CreateProcess() and CreateProcessAsUser()
enum : DWORD {
    DEBUG_PROCESS               = 0x00000001,
    DEBUG_ONLY_THIS_PROCESS     = 0x00000002,
    CREATE_SUSPENDED            = 0x00000004,
    DETACHED_PROCESS            = 0x00000008,
    CREATE_NEW_CONSOLE          = 0x00000010,
    NORMAL_PRIORITY_CLASS       = 0x00000020,
    IDLE_PRIORITY_CLASS         = 0x00000040,
    HIGH_PRIORITY_CLASS         = 0x00000080,
    REALTIME_PRIORITY_CLASS     = 0x00000100,
    CREATE_NEW_PROCESS_GROUP    = 0x00000200,
    CREATE_UNICODE_ENVIRONMENT  = 0x00000400,
    CREATE_SEPARATE_WOW_VDM     = 0x00000800,
    CREATE_SHARED_WOW_VDM       = 0x00001000,
    CREATE_FORCEDOS             = 0x00002000,
    BELOW_NORMAL_PRIORITY_CLASS = 0x00004000,
    ABOVE_NORMAL_PRIORITY_CLASS = 0x00008000,
    CREATE_BREAKAWAY_FROM_JOB   = 0x01000000,
    CREATE_WITH_USERPROFILE     = 0x02000000,
    CREATE_DEFAULT_ERROR_MODE   = 0x04000000,
    CREATE_NO_WINDOW            = 0x08000000,
    PROFILE_USER                = 0x10000000,
    PROFILE_KERNEL              = 0x20000000,
    PROFILE_SERVER              = 0x40000000
}

enum DWORD CONSOLE_TEXTMODE_BUFFER = 1;

// CreateFile()
enum : DWORD {
    CREATE_NEW = 1,
    CREATE_ALWAYS,
    OPEN_EXISTING,
    OPEN_ALWAYS,
    TRUNCATE_EXISTING
}

// CreateFile()
enum DWORD
    FILE_FLAG_WRITE_THROUGH      = 0x80000000,
    FILE_FLAG_OVERLAPPED         = 0x40000000,
    FILE_FLAG_NO_BUFFERING       = 0x20000000,
    FILE_FLAG_RANDOM_ACCESS      = 0x10000000,
    FILE_FLAG_SEQUENTIAL_SCAN    = 0x08000000,
    FILE_FLAG_DELETE_ON_CLOSE    = 0x04000000,
    FILE_FLAG_BACKUP_SEMANTICS   = 0x02000000,
    FILE_FLAG_POSIX_SEMANTICS    = 0x01000000,
    FILE_FLAG_OPEN_REPARSE_POINT = 0x00200000,
    FILE_FLAG_OPEN_NO_RECALL     = 0x00100000;

static if (_WIN32_WINNT >= 0x500) {
enum DWORD FILE_FLAG_FIRST_PIPE_INSTANCE = 0x00080000;
}

// for CreateFile()
enum DWORD
    SECURITY_ANONYMOUS        = SECURITY_IMPERSONATION_LEVEL.SecurityAnonymous<<16,
    SECURITY_IDENTIFICATION   = SECURITY_IMPERSONATION_LEVEL.SecurityIdentification<<16,
    SECURITY_IMPERSONATION    = SECURITY_IMPERSONATION_LEVEL.SecurityImpersonation<<16,
    SECURITY_DELEGATION       = SECURITY_IMPERSONATION_LEVEL.SecurityDelegation<<16,
    SECURITY_CONTEXT_TRACKING = 0x00040000,
    SECURITY_EFFECTIVE_ONLY   = 0x00080000,
    SECURITY_SQOS_PRESENT     = 0x00100000,
    SECURITY_VALID_SQOS_FLAGS = 0x001F0000;

// for GetFinalPathNameByHandle()
enum DWORD
    VOLUME_NAME_DOS      = 0x0,
    VOLUME_NAME_GUID     = 0x1,
    VOLUME_NAME_NT       = 0x2,
    VOLUME_NAME_NONE     = 0x4,
    FILE_NAME_NORMALIZED = 0x0,
    FILE_NAME_OPENED     = 0x8;

// Thread exit code
enum DWORD STILL_ACTIVE = 0x103;

/*  ??? The only documentation of this seems to be about Windows CE and to
 *  state what _doesn't_ support it.
 */
enum DWORD FIND_FIRST_EX_CASE_SENSITIVE = 1;

// GetBinaryType()
enum : DWORD {
    SCS_32BIT_BINARY = 0,
    SCS_DOS_BINARY,
    SCS_WOW_BINARY,
    SCS_PIF_BINARY,
    SCS_POSIX_BINARY,
    SCS_OS216_BINARY
}

enum size_t
    MAX_COMPUTERNAME_LENGTH = 15,
    HW_PROFILE_GUIDLEN      = 39,
    MAX_PROFILE_LEN         = 80;

// HW_PROFILE_INFO
enum DWORD
    DOCKINFO_UNDOCKED      = 1,
    DOCKINFO_DOCKED        = 2,
    DOCKINFO_USER_SUPPLIED = 4,
    DOCKINFO_USER_UNDOCKED = DOCKINFO_USER_SUPPLIED | DOCKINFO_UNDOCKED,
    DOCKINFO_USER_DOCKED   = DOCKINFO_USER_SUPPLIED | DOCKINFO_DOCKED;

// DriveType(), RealDriveType()
enum : int {
    DRIVE_UNKNOWN = 0,
    DRIVE_NO_ROOT_DIR,
    DRIVE_REMOVABLE,
    DRIVE_FIXED,
    DRIVE_REMOTE,
    DRIVE_CDROM,
    DRIVE_RAMDISK
}

// GetFileType()
enum : DWORD {
    FILE_TYPE_UNKNOWN = 0,
    FILE_TYPE_DISK,
    FILE_TYPE_CHAR,
    FILE_TYPE_PIPE,
    FILE_TYPE_REMOTE = 0x8000
}

// Get/SetHandleInformation()
enum DWORD
    HANDLE_FLAG_INHERIT            = 0x01,
    HANDLE_FLAG_PROTECT_FROM_CLOSE = 0x02;

enum : DWORD {
    STD_INPUT_HANDLE  = 0xFFFFFFF6,
    STD_OUTPUT_HANDLE = 0xFFFFFFF5,
    STD_ERROR_HANDLE  = 0xFFFFFFF4
}

@trusted enum HANDLE INVALID_HANDLE_VALUE = cast(HANDLE) (-1);

enum : DWORD {
    GET_TAPE_MEDIA_INFORMATION = 0,
    GET_TAPE_DRIVE_INFORMATION = 1
}

enum : DWORD {
    SET_TAPE_MEDIA_INFORMATION = 0,
    SET_TAPE_DRIVE_INFORMATION = 1
}

// SetThreadPriority()/GetThreadPriority()
enum : int {
    THREAD_PRIORITY_IDLE          = -15,
    THREAD_PRIORITY_LOWEST        =  -2,
    THREAD_PRIORITY_BELOW_NORMAL  =  -1,
    THREAD_PRIORITY_NORMAL        =   0,
    THREAD_PRIORITY_ABOVE_NORMAL  =   1,
    THREAD_PRIORITY_HIGHEST       =   2,
    THREAD_PRIORITY_TIME_CRITICAL =  15,
    THREAD_PRIORITY_ERROR_RETURN  = 2147483647
}

enum : DWORD {
    TIME_ZONE_ID_UNKNOWN,
    TIME_ZONE_ID_STANDARD,
    TIME_ZONE_ID_DAYLIGHT,
    TIME_ZONE_ID_INVALID = 0xFFFFFFFF
}

enum DWORD
    FS_CASE_SENSITIVE         =     1,
    FS_CASE_IS_PRESERVED      =     2,
    FS_UNICODE_STORED_ON_DISK =     4,
    FS_PERSISTENT_ACLS        =     8,
    FS_FILE_COMPRESSION       =    16,
    FS_VOL_IS_COMPRESSED      = 32768;

// Flags for GlobalAlloc
enum UINT
    GMEM_FIXED       = 0,
    GMEM_MOVEABLE    = 0x0002,
    GMEM_ZEROINIT    = 0x0040,
    GPTR             = 0x0040,
    GHND             = 0x0042,
    GMEM_MODIFY      = 0x0080,  // used only for GlobalRealloc
    GMEM_VALID_FLAGS = 0x7F72;

/+  // Obselete flags (Win16 only)
    GMEM_NOCOMPACT=16;
    GMEM_NODISCARD=32;
    GMEM_DISCARDABLE=256;
    GMEM_NOT_BANKED=4096;
    GMEM_LOWER=4096;
    GMEM_SHARE=8192;
    GMEM_DDESHARE=8192;

    GMEM_LOCKCOUNT=255;

// for GlobalFlags()
    GMEM_DISCARDED      = 16384;
    GMEM_INVALID_HANDLE = 32768;

    GMEM_NOTIFY         = 16384;
+/

enum UINT
    LMEM_FIXED          = 0,
    LMEM_MOVEABLE       = 0x0002,
    LMEM_NONZEROLPTR    = 0,
    NONZEROLPTR         = 0,
    LMEM_NONZEROLHND    = 0x0002,
    NONZEROLHND         = 0x0002,
    LMEM_DISCARDABLE    = 0x0F00,
    LMEM_NOCOMPACT      = 0x0010,
    LMEM_NODISCARD      = 0x0020,
    LMEM_ZEROINIT       = 0x0040,
    LPTR                = 0x0040,
    LHND                = 0x0042,
    LMEM_MODIFY         = 0x0080,
    LMEM_LOCKCOUNT      = 0x00FF,
    LMEM_DISCARDED      = 0x4000,
    LMEM_INVALID_HANDLE = 0x8000;



// used in EXCEPTION_RECORD
enum : DWORD {
    STATUS_WAIT_0                      = 0,
    STATUS_ABANDONED_WAIT_0            = 0x00000080,
    STATUS_USER_APC                    = 0x000000C0,
    STATUS_TIMEOUT                     = 0x00000102,
    STATUS_PENDING                     = 0x00000103,

    STATUS_SEGMENT_NOTIFICATION        = 0x40000005,
    STATUS_GUARD_PAGE_VIOLATION        = 0x80000001,
    STATUS_DATATYPE_MISALIGNMENT       = 0x80000002,
    STATUS_BREAKPOINT                  = 0x80000003,
    STATUS_SINGLE_STEP                 = 0x80000004,

    STATUS_ACCESS_VIOLATION            = 0xC0000005,
    STATUS_IN_PAGE_ERROR               = 0xC0000006,
    STATUS_INVALID_HANDLE              = 0xC0000008,

    STATUS_NO_MEMORY                   = 0xC0000017,
    STATUS_ILLEGAL_INSTRUCTION         = 0xC000001D,
    STATUS_NONCONTINUABLE_EXCEPTION    = 0xC0000025,
    STATUS_INVALID_DISPOSITION         = 0xC0000026,
    STATUS_ARRAY_BOUNDS_EXCEEDED       = 0xC000008C,
    STATUS_FLOAT_DENORMAL_OPERAND      = 0xC000008D,
    STATUS_FLOAT_DIVIDE_BY_ZERO        = 0xC000008E,
    STATUS_FLOAT_INEXACT_RESULT        = 0xC000008F,
    STATUS_FLOAT_INVALID_OPERATION     = 0xC0000090,
    STATUS_FLOAT_OVERFLOW              = 0xC0000091,
    STATUS_FLOAT_STACK_CHECK           = 0xC0000092,
    STATUS_FLOAT_UNDERFLOW             = 0xC0000093,
    STATUS_INTEGER_DIVIDE_BY_ZERO      = 0xC0000094,
    STATUS_INTEGER_OVERFLOW            = 0xC0000095,
    STATUS_PRIVILEGED_INSTRUCTION      = 0xC0000096,
    STATUS_STACK_OVERFLOW              = 0xC00000FD,
    STATUS_CONTROL_C_EXIT              = 0xC000013A,
    STATUS_DLL_INIT_FAILED             = 0xC0000142,
    STATUS_DLL_INIT_FAILED_LOGOFF      = 0xC000026B,

    CONTROL_C_EXIT                     = STATUS_CONTROL_C_EXIT,

    EXCEPTION_ACCESS_VIOLATION         = STATUS_ACCESS_VIOLATION,
    EXCEPTION_DATATYPE_MISALIGNMENT    = STATUS_DATATYPE_MISALIGNMENT,
    EXCEPTION_BREAKPOINT               = STATUS_BREAKPOINT,
    EXCEPTION_SINGLE_STEP              = STATUS_SINGLE_STEP,
    EXCEPTION_ARRAY_BOUNDS_EXCEEDED    = STATUS_ARRAY_BOUNDS_EXCEEDED,
    EXCEPTION_FLT_DENORMAL_OPERAND     = STATUS_FLOAT_DENORMAL_OPERAND,
    EXCEPTION_FLT_DIVIDE_BY_ZERO       = STATUS_FLOAT_DIVIDE_BY_ZERO,
    EXCEPTION_FLT_INEXACT_RESULT       = STATUS_FLOAT_INEXACT_RESULT,
    EXCEPTION_FLT_INVALID_OPERATION    = STATUS_FLOAT_INVALID_OPERATION,
    EXCEPTION_FLT_OVERFLOW             = STATUS_FLOAT_OVERFLOW,
    EXCEPTION_FLT_STACK_CHECK          = STATUS_FLOAT_STACK_CHECK,
    EXCEPTION_FLT_UNDERFLOW            = STATUS_FLOAT_UNDERFLOW,
    EXCEPTION_INT_DIVIDE_BY_ZERO       = STATUS_INTEGER_DIVIDE_BY_ZERO,
    EXCEPTION_INT_OVERFLOW             = STATUS_INTEGER_OVERFLOW,
    EXCEPTION_PRIV_INSTRUCTION         = STATUS_PRIVILEGED_INSTRUCTION,
    EXCEPTION_IN_PAGE_ERROR            = STATUS_IN_PAGE_ERROR,
    EXCEPTION_ILLEGAL_INSTRUCTION      = STATUS_ILLEGAL_INSTRUCTION,
    EXCEPTION_NONCONTINUABLE_EXCEPTION = STATUS_NONCONTINUABLE_EXCEPTION,
    EXCEPTION_STACK_OVERFLOW           = STATUS_STACK_OVERFLOW,
    EXCEPTION_INVALID_DISPOSITION      = STATUS_INVALID_DISPOSITION,
    EXCEPTION_GUARD_PAGE               = STATUS_GUARD_PAGE_VIOLATION,
    EXCEPTION_INVALID_HANDLE           = STATUS_INVALID_HANDLE
}

// for PROCESS_HEAP_ENTRY
enum WORD
    PROCESS_HEAP_REGION            =  1,
    PROCESS_HEAP_UNCOMMITTED_RANGE =  2,
    PROCESS_HEAP_ENTRY_BUSY        =  4,
    PROCESS_HEAP_ENTRY_MOVEABLE    = 16,
    PROCESS_HEAP_ENTRY_DDESHARE    = 32;

// for LoadLibraryEx()
enum DWORD
    DONT_RESOLVE_DLL_REFERENCES   = 0x01, // not for WinME and earlier
    LOAD_LIBRARY_AS_DATAFILE      = 0x02,
    LOAD_WITH_ALTERED_SEARCH_PATH = 0x08,
    LOAD_IGNORE_CODE_AUTHZ_LEVEL  = 0x10; // only for XP and later

// for LockFile()
enum DWORD
    LOCKFILE_FAIL_IMMEDIATELY = 1,
    LOCKFILE_EXCLUSIVE_LOCK   = 2;

enum MAXIMUM_WAIT_OBJECTS  = 64;
enum MAXIMUM_SUSPEND_COUNT = 0x7F;

enum WAIT_OBJECT_0    = 0;
enum WAIT_ABANDONED_0 = 128;

//const WAIT_TIMEOUT=258;  // also in winerror.h

enum : DWORD {
    WAIT_IO_COMPLETION = 0x000000C0,
    WAIT_ABANDONED     = 0x00000080,
    WAIT_FAILED        = 0xFFFFFFFF
}

// PurgeComm()
enum DWORD
    PURGE_TXABORT = 1,
    PURGE_RXABORT = 2,
    PURGE_TXCLEAR = 4,
    PURGE_RXCLEAR = 8;

// ReadEventLog()
enum DWORD
    EVENTLOG_SEQUENTIAL_READ = 1,
    EVENTLOG_SEEK_READ       = 2,
    EVENTLOG_FORWARDS_READ   = 4,
    EVENTLOG_BACKWARDS_READ  = 8;

// ReportEvent()
enum : WORD {
    EVENTLOG_SUCCESS          = 0,
    EVENTLOG_ERROR_TYPE       = 1,
    EVENTLOG_WARNING_TYPE     = 2,
    EVENTLOG_INFORMATION_TYPE = 4,
    EVENTLOG_AUDIT_SUCCESS    = 8,
    EVENTLOG_AUDIT_FAILURE    = 16
}

// FormatMessage()
enum DWORD
    FORMAT_MESSAGE_ALLOCATE_BUFFER = 0x0100,
    FORMAT_MESSAGE_IGNORE_INSERTS  = 0x0200,
    FORMAT_MESSAGE_FROM_STRING     = 0x0400,
    FORMAT_MESSAGE_FROM_HMODULE    = 0x0800,
    FORMAT_MESSAGE_FROM_SYSTEM     = 0x1000,
    FORMAT_MESSAGE_ARGUMENT_ARRAY  = 0x2000;

enum DWORD FORMAT_MESSAGE_MAX_WIDTH_MASK = 255;

// also in ddk/ntapi.h
// To restore default error mode, call SetErrorMode(0)
enum {
    SEM_FAILCRITICALERRORS     = 0x0001,
    SEM_NOGPFAULTERRORBOX      = 0x0002,
    SEM_NOALIGNMENTFAULTEXCEPT = 0x0004,
    SEM_NOOPENFILEERRORBOX     = 0x8000
}
// end ntapi.h

enum {
    SLE_ERROR = 1,
    SLE_MINORERROR,
    SLE_WARNING
}

enum SHUTDOWN_NORETRY = 1;

// Return type for exception filters.
enum : LONG {
    EXCEPTION_EXECUTE_HANDLER    =  1,
    EXCEPTION_CONTINUE_EXECUTION = -1,
    EXCEPTION_CONTINUE_SEARCH    =  0
}

enum  : ATOM {
    MAXINTATOM   = 0xC000,
    INVALID_ATOM = 0
}

enum IGNORE   = 0;
enum INFINITE = 0xFFFFFFFF;

// EscapeCommFunction()
enum {
    SETXOFF    = 1,
    SETXON,
    SETRTS,
    CLRRTS,
    SETDTR,
    CLRDTR, // = 6
    SETBREAK   = 8,
    CLRBREAK   = 9
}


// for SetCommMask()
enum DWORD
    EV_RXCHAR   = 0x0001,
    EV_RXFLAG   = 0x0002,
    EV_TXEMPTY  = 0x0004,
    EV_CTS      = 0x0008,
    EV_DSR      = 0x0010,
    EV_RLSD     = 0x0020,
    EV_BREAK    = 0x0040,
    EV_ERR      = 0x0080,
    EV_RING     = 0x0100,
    EV_PERR     = 0x0200,
    EV_RX80FULL = 0x0400,
    EV_EVENT1   = 0x0800,
    EV_EVENT2   = 0x1000;

// GetCommModemStatus()
enum DWORD
    MS_CTS_ON  = 0x0010,
    MS_DSR_ON  = 0x0020,
    MS_RING_ON = 0x0040,
    MS_RLSD_ON = 0x0080;


// DCB
enum : BYTE {
    NOPARITY = 0,
    ODDPARITY,
    EVENPARITY,
    MARKPARITY,
    SPACEPARITY
}
// DCB
enum : BYTE {
    ONESTOPBIT = 0,
    ONE5STOPBITS,
    TWOSTOPBITS
}
// DCB
enum : DWORD {
    CBR_110    =    110,
    CBR_300    =    300,
    CBR_600    =    600,
    CBR_1200   =   1200,
    CBR_2400   =   2400,
    CBR_4800   =   4800,
    CBR_9600   =   9600,
    CBR_14400  =  14400,
    CBR_19200  =  19200,
    CBR_38400  =  38400,
    CBR_56000  =  56000,
    CBR_57600  =  57600,
    CBR_115200 = 115200,
    CBR_128000 = 128000,
    CBR_256000 = 256000
}
// DCB, 2-bit bitfield
enum {
    DTR_CONTROL_DISABLE = 0,
    DTR_CONTROL_ENABLE,
    DTR_CONTROL_HANDSHAKE
}

// DCB, 2-bit bitfield
enum {
    RTS_CONTROL_DISABLE = 0,
    RTS_CONTROL_ENABLE,
    RTS_CONTROL_HANDSHAKE,
    RTS_CONTROL_TOGGLE,
}

// WIN32_STREAM_ID
enum : DWORD {
    BACKUP_INVALID = 0,
    BACKUP_DATA,
    BACKUP_EA_DATA,
    BACKUP_SECURITY_DATA,
    BACKUP_ALTERNATE_DATA,
    BACKUP_LINK,
    BACKUP_PROPERTY_DATA,
    BACKUP_OBJECT_ID,
    BACKUP_REPARSE_DATA,
    BACKUP_SPARSE_BLOCK
}

// WIN32_STREAM_ID
enum : DWORD {
    STREAM_NORMAL_ATTRIBUTE    = 0,
    STREAM_MODIFIED_WHEN_READ  = 1,
    STREAM_CONTAINS_SECURITY   = 2,
    STREAM_CONTAINS_PROPERTIES = 4
}

// STARTUPINFO
enum DWORD
    STARTF_USESHOWWINDOW    = 0x0001,
    STARTF_USESIZE          = 0x0002,
    STARTF_USEPOSITION      = 0x0004,
    STARTF_USECOUNTCHARS    = 0x0008,
    STARTF_USEFILLATTRIBUTE = 0x0010,
    STARTF_RUNFULLSCREEN    = 0x0020,
    STARTF_FORCEONFEEDBACK  = 0x0040,
    STARTF_FORCEOFFFEEDBACK = 0x0080,
    STARTF_USESTDHANDLES    = 0x0100,
    STARTF_USEHOTKEY        = 0x0200;

// ???
enum {
    TC_NORMAL  = 0,
    TC_HARDERR = 1,
    TC_GP_TRAP = 2,
    TC_SIGNAL  = 3
}

/+ These seem to be Windows CE-specific
enum {
    AC_LINE_OFFLINE      = 0,
    AC_LINE_ONLINE       = 1,
    AC_LINE_BACKUP_POWER = 2,
    AC_LINE_UNKNOWN      = 255
}

enum {
    BATTERY_FLAG_HIGH          = 1,
    BATTERY_FLAG_LOW           = 2,
    BATTERY_FLAG_CRITICAL      = 4,
    BATTERY_FLAG_CHARGING      = 8,
    BATTERY_FLAG_NO_BATTERY    = 128,
    BATTERY_FLAG_UNKNOWN       = 255,
    BATTERY_PERCENTAGE_UNKNOWN = 255,
    BATTERY_LIFE_UNKNOWN       = 0xFFFFFFFF
}
+/

// ???
enum HINSTANCE_ERROR = 32;

// returned from GetFileSize()
enum DWORD INVALID_FILE_SIZE = 0xFFFFFFFF;

enum DWORD TLS_OUT_OF_INDEXES = 0xFFFFFFFF;

// GetWriteWatch()
enum DWORD WRITE_WATCH_FLAG_RESET = 1;

// for LogonUser()
enum : DWORD {
    LOGON32_LOGON_INTERACTIVE = 2,
    LOGON32_LOGON_NETWORK     = 3,
    LOGON32_LOGON_BATCH       = 4,
    LOGON32_LOGON_SERVICE     = 5,
    LOGON32_LOGON_UNLOCK      = 7
}

// for LogonUser()
enum : DWORD {
    LOGON32_PROVIDER_DEFAULT,
    LOGON32_PROVIDER_WINNT35,
    LOGON32_PROVIDER_WINNT40,
    LOGON32_PROVIDER_WINNT50
}

// for MoveFileEx()
enum DWORD
    MOVEFILE_REPLACE_EXISTING   = 1,
    MOVEFILE_COPY_ALLOWED       = 2,
    MOVEFILE_DELAY_UNTIL_REBOOT = 4,
    MOVEFILE_WRITE_THROUGH      = 8;

// DefineDosDevice()
enum DWORD
    DDD_RAW_TARGET_PATH       = 1,
    DDD_REMOVE_DEFINITION     = 2,
    DDD_EXACT_MATCH_ON_REMOVE = 4;

static if (_WIN32_WINNT >= 0x500) {
    enum : DWORD {
        LOGON32_LOGON_NETWORK_CLEARTEXT = 8,
        LOGON32_LOGON_NEW_CREDENTIALS   = 9
    }

    // ReplaceFile()
enum DWORD
        REPLACEFILE_WRITE_THROUGH       = 1,
        REPLACEFILE_IGNORE_MERGE_ERRORS = 2;
}

static if (_WIN32_WINNT >= 0x501) {
enum DWORD
        GET_MODULE_HANDLE_EX_FLAG_PIN                = 1,
        GET_MODULE_HANDLE_EX_FLAG_UNCHANGED_REFCOUNT = 2,
        GET_MODULE_HANDLE_EX_FLAG_FROM_ADDRESS       = 4;

    // for ACTCTX
enum DWORD
        ACTCTX_FLAG_PROCESSOR_ARCHITECTURE_VALID = 0x01,
        ACTCTX_FLAG_LANGID_VALID                 = 0x02,
        ACTCTX_FLAG_ASSEMBLY_DIRECTORY_VALID     = 0x04,
        ACTCTX_FLAG_RESOURCE_NAME_VALID          = 0x08,
        ACTCTX_FLAG_SET_PROCESS_DEFAULT          = 0x10,
        ACTCTX_FLAG_APPLICATION_NAME_VALID       = 0x20,
        ACTCTX_FLAG_HMODULE_VALID                = 0x80;

    // DeactivateActCtx()
enum DWORD DEACTIVATE_ACTCTX_FLAG_FORCE_EARLY_DEACTIVATION = 1;
    // FindActCtxSectionString()
enum DWORD FIND_ACTCTX_SECTION_KEY_RETURN_HACTCTX          = 1;
    // QueryActCtxW()
enum DWORD
        QUERY_ACTCTX_FLAG_USE_ACTIVE_ACTCTX             = 0x04,
        QUERY_ACTCTX_FLAG_ACTCTX_IS_HMODULE             = 0x08,
        QUERY_ACTCTX_FLAG_ACTCTX_IS_ADDRESS             = 0x10;

    enum {
        LOGON_WITH_PROFILE        = 1,
        LOGON_NETCREDENTIALS_ONLY
    }
}

// ----

struct FILETIME {
    DWORD dwLowDateTime;
    DWORD dwHighDateTime;
}
alias PFILETIME = FILETIME*, LPFILETIME = FILETIME*;

struct BY_HANDLE_FILE_INFORMATION {
    DWORD    dwFileAttributes;
    FILETIME ftCreationTime;
    FILETIME ftLastAccessTime;
    FILETIME ftLastWriteTime;
    DWORD    dwVolumeSerialNumber;
    DWORD    nFileSizeHigh;
    DWORD    nFileSizeLow;
    DWORD    nNumberOfLinks;
    DWORD    nFileIndexHigh;
    DWORD    nFileIndexLow;
}
alias LPBY_HANDLE_FILE_INFORMATION = BY_HANDLE_FILE_INFORMATION*;

struct DCB {
    DWORD DCBlength = DCB.sizeof;
    DWORD BaudRate;
/+
    DWORD fBinary:1;              // Binary Mode (skip EOF check)
    DWORD fParity:1;              // Enable parity checking
    DWORD fOutxCtsFlow:1;         // CTS handshaking on output
    DWORD fOutxDsrFlow:1;         // DSR handshaking on output
    DWORD fDtrControl:2;          // DTR Flow control
    DWORD fDsrSensitivity:1;      // DSR Sensitivity
    DWORD fTXContinueOnXoff:1;    // Continue TX when Xoff sent
    DWORD fOutX:1;                // Enable output X-ON/X-OFF
    DWORD fInX:1;                 // Enable input X-ON/X-OFF
    DWORD fErrorChar:1;           // Enable Err Replacement
    DWORD fNull:1;                // Enable Null stripping
    DWORD fRtsControl:2;          // Rts Flow control
    DWORD fAbortOnError:1;        // Abort all reads and writes on Error
    DWORD fDummy2:17;             // Reserved
+/
    uint _bf;
    bool fBinary(bool f)           { _bf = (_bf & ~0x0001) | f; return f; }
    bool fParity(bool f)           { _bf = (_bf & ~0x0002) | (f<<1); return f; }
    bool fOutxCtsFlow(bool f)      { _bf = (_bf & ~0x0004) | (f<<2); return f; }
    bool fOutxDsrFlow(bool f)      { _bf = (_bf & ~0x0008) | (f<<3); return f; }
    byte fDtrControl(byte x)       { _bf = (_bf & ~0x0030) | (x<<4); return cast(byte)(x & 3); }
    bool fDsrSensitivity(bool f)   { _bf = (_bf & ~0x0040) | (f<<6); return f; }
    bool fTXContinueOnXoff(bool f) { _bf = (_bf & ~0x0080) | (f<<7); return f; }
    bool fOutX(bool f)             { _bf = (_bf & ~0x0100) | (f<<8); return f; }
    bool fInX(bool f)              { _bf = (_bf & ~0x0200) | (f<<9); return f; }
    bool fErrorChar(bool f)        { _bf = (_bf & ~0x0400) | (f<<10); return f; }
    bool fNull(bool f)             { _bf = (_bf & ~0x0800) | (f<<11); return f; }
    byte fRtsControl(byte x)       { _bf = (_bf & ~0x3000) | (x<<12); return cast(byte)(x & 3); }
    bool fAbortOnError(bool f)     { _bf = (_bf & ~0x4000) | (f<<14); return f; }

    bool fBinary()           { return cast(bool) (_bf & 1); }
    bool fParity()           { return cast(bool) (_bf & 2); }
    bool fOutxCtsFlow()      { return cast(bool) (_bf & 4); }
    bool fOutxDsrFlow()      { return cast(bool) (_bf & 8); }
    byte fDtrControl()       { return cast(byte) ((_bf & (32+16))>>4); }
    bool fDsrSensitivity()   { return cast(bool) (_bf & 64); }
    bool fTXContinueOnXoff()() { return cast(bool) (_bf & 128); }
    bool fOutX()             { return cast(bool) (_bf & 256); }
    bool fInX()              { return cast(bool) (_bf & 512); }
    bool fErrorChar()        { return cast(bool) (_bf & 1024); }
    bool fNull()             { return cast(bool) (_bf & 2048); }
    byte fRtsControl()       { return cast(byte) ((_bf & (4096+8192))>>12); }
    bool fAbortOnError()     { return cast(bool) (_bf & 16384); }

    WORD wReserved;
    WORD XonLim;
    WORD XoffLim;
    BYTE ByteSize;
    BYTE Parity;
    BYTE StopBits;
    char XonChar = 0;
    char XoffChar = 0;
    char ErrorChar = 0;
    char EofChar = 0;
    char EvtChar = 0;
    WORD wReserved1;
}
alias LPDCB = DCB*;

struct COMMCONFIG {
    DWORD dwSize = COMMCONFIG.sizeof;
    WORD  wVersion;
    WORD  wReserved;
    DCB   dcb;
    DWORD dwProviderSubType;
    DWORD dwProviderOffset;
    DWORD dwProviderSize;
    WCHAR _wcProviderData = 0;

    WCHAR* wcProviderData() return { return &_wcProviderData; }
}
alias LPCOMMCONFIG = COMMCONFIG*;

struct COMMTIMEOUTS {
    DWORD ReadIntervalTimeout;
    DWORD ReadTotalTimeoutMultiplier;
    DWORD ReadTotalTimeoutConstant;
    DWORD WriteTotalTimeoutMultiplier;
    DWORD WriteTotalTimeoutConstant;
}
alias LPCOMMTIMEOUTS = COMMTIMEOUTS*;

struct COMSTAT {
/+
    DWORD fCtsHold:1;
    DWORD fDsrHold:1;
    DWORD fRlsdHold:1;
    DWORD fXoffHold:1;
    DWORD fXoffSent:1;
    DWORD fEof:1;
    DWORD fTxim:1;
    DWORD fReserved:25;
+/
    DWORD _bf;
    bool fCtsHold(bool f)  { _bf = (_bf & ~1) | f; return f; }
    bool fDsrHold(bool f)  { _bf = (_bf & ~2) | (f<<1); return f; }
    bool fRlsdHold(bool f) { _bf = (_bf & ~4) | (f<<2); return f; }
    bool fXoffHold(bool f) { _bf = (_bf & ~8) | (f<<3); return f; }
    bool fXoffSent(bool f) { _bf = (_bf & ~16) | (f<<4); return f; }
    bool fEof(bool f)      { _bf = (_bf & ~32) | (f<<5); return f; }
    bool fTxim(bool f)     { _bf = (_bf & ~64) | (f<<6); return f; }

    bool fCtsHold()  { return cast(bool) (_bf & 1); }
    bool fDsrHold()  { return cast(bool) (_bf & 2); }
    bool fRlsdHold()() { return cast(bool) (_bf & 4); }
    bool fXoffHold()() { return cast(bool) (_bf & 8); }
    bool fXoffSent()() { return cast(bool) (_bf & 16); }
    bool fEof()      { return cast(bool) (_bf & 32); }
    bool fTxim()     { return cast(bool) (_bf & 64); }

    DWORD cbInQue;
    DWORD cbOutQue;
}
alias LPCOMSTAT = COMSTAT*;

struct CREATE_PROCESS_DEBUG_INFO {
    HANDLE hFile;
    HANDLE hProcess;
    HANDLE hThread;
    LPVOID lpBaseOfImage;
    DWORD  dwDebugInfoFileOffset;
    DWORD  nDebugInfoSize;
    LPVOID lpThreadLocalBase;
    LPTHREAD_START_ROUTINE lpStartAddress;
    LPVOID lpImageName;
    WORD   fUnicode;
}
alias LPCREATE_PROCESS_DEBUG_INFO = CREATE_PROCESS_DEBUG_INFO*;

struct CREATE_THREAD_DEBUG_INFO {
    HANDLE hThread;
    LPVOID lpThreadLocalBase;
    LPTHREAD_START_ROUTINE lpStartAddress;
}
alias LPCREATE_THREAD_DEBUG_INFO = CREATE_THREAD_DEBUG_INFO*;

struct EXCEPTION_DEBUG_INFO {
    EXCEPTION_RECORD ExceptionRecord;
    DWORD            dwFirstChance;
}
alias LPEXCEPTION_DEBUG_INFO = EXCEPTION_DEBUG_INFO*;

struct EXIT_THREAD_DEBUG_INFO {
    DWORD dwExitCode;
}
alias LPEXIT_THREAD_DEBUG_INFO = EXIT_THREAD_DEBUG_INFO*;

struct EXIT_PROCESS_DEBUG_INFO {
    DWORD dwExitCode;
}
alias LPEXIT_PROCESS_DEBUG_INFO = EXIT_PROCESS_DEBUG_INFO*;

struct LOAD_DLL_DEBUG_INFO {
    HANDLE hFile;
    LPVOID lpBaseOfDll;
    DWORD  dwDebugInfoFileOffset;
    DWORD  nDebugInfoSize;
    LPVOID lpImageName;
    WORD   fUnicode;
}
alias LPLOAD_DLL_DEBUG_INFO = LOAD_DLL_DEBUG_INFO*;

struct UNLOAD_DLL_DEBUG_INFO {
    LPVOID lpBaseOfDll;
}
alias LPUNLOAD_DLL_DEBUG_INFO = UNLOAD_DLL_DEBUG_INFO*;

struct OUTPUT_DEBUG_STRING_INFO {
    LPSTR lpDebugStringData;
    WORD  fUnicode;
    WORD  nDebugStringLength;
}
alias LPOUTPUT_DEBUG_STRING_INFO = OUTPUT_DEBUG_STRING_INFO*;

struct RIP_INFO {
    DWORD dwError;
    DWORD dwType;
}
alias LPRIP_INFO = RIP_INFO*;

struct DEBUG_EVENT {
    DWORD dwDebugEventCode;
    DWORD dwProcessId;
    DWORD dwThreadId;
    union {
        EXCEPTION_DEBUG_INFO      Exception;
        CREATE_THREAD_DEBUG_INFO  CreateThread;
        CREATE_PROCESS_DEBUG_INFO CreateProcessInfo;
        EXIT_THREAD_DEBUG_INFO    ExitThread;
        EXIT_PROCESS_DEBUG_INFO   ExitProcess;
        LOAD_DLL_DEBUG_INFO       LoadDll;
        UNLOAD_DLL_DEBUG_INFO     UnloadDll;
        OUTPUT_DEBUG_STRING_INFO  DebugString;
        RIP_INFO                  RipInfo;
    }
}
alias LPDEBUG_EVENT = DEBUG_EVENT*;

struct OVERLAPPED {
    ULONG_PTR Internal;
    ULONG_PTR InternalHigh;
    union {
        struct {
            DWORD     Offset;
            DWORD     OffsetHigh;
        }
        PVOID     Pointer;
    }
    HANDLE    hEvent;
}
alias POVERLAPPED = OVERLAPPED*, LPOVERLAPPED = OVERLAPPED*;

struct STARTUPINFOA {
    DWORD  cb = STARTUPINFOA.sizeof;
    LPSTR  lpReserved;
    LPSTR  lpDesktop;
    LPSTR  lpTitle;
    DWORD  dwX;
    DWORD  dwY;
    DWORD  dwXSize;
    DWORD  dwYSize;
    DWORD  dwXCountChars;
    DWORD  dwYCountChars;
    DWORD  dwFillAttribute;
    DWORD  dwFlags;
    WORD   wShowWindow;
    WORD   cbReserved2;
    PBYTE  lpReserved2;
    HANDLE hStdInput;
    HANDLE hStdOutput;
    HANDLE hStdError;
}
alias LPSTARTUPINFOA = STARTUPINFOA*;

struct STARTUPINFOW {
    DWORD  cb = STARTUPINFOW.sizeof;
    LPWSTR lpReserved;
    LPWSTR lpDesktop;
    LPWSTR lpTitle;
    DWORD  dwX;
    DWORD  dwY;
    DWORD  dwXSize;
    DWORD  dwYSize;
    DWORD  dwXCountChars;
    DWORD  dwYCountChars;
    DWORD  dwFillAttribute;
    DWORD  dwFlags;
    WORD   wShowWindow;
    WORD   cbReserved2;
    PBYTE  lpReserved2;
    HANDLE hStdInput;
    HANDLE hStdOutput;
    HANDLE hStdError;
}
alias STARTUPINFO_W = STARTUPINFOW;
alias LPSTARTUPINFOW = STARTUPINFOW*, LPSTARTUPINFO_W = STARTUPINFOW*;

struct PROCESS_INFORMATION {
    HANDLE hProcess;
    HANDLE hThread;
    DWORD  dwProcessId;
    DWORD  dwThreadId;
}
alias PPROCESS_INFORMATION = PROCESS_INFORMATION*, LPPROCESS_INFORMATION = PROCESS_INFORMATION*;

/*
struct CRITICAL_SECTION_DEBUG {
    WORD              Type;
    WORD              CreatorBackTraceIndex;
    CRITICAL_SECTION* CriticalSection;
    LIST_ENTRY        ProcessLocksList;
    DWORD             EntryCount;
    DWORD             ContentionCount;
    DWORD[2]          Spare;
}
alias CRITICAL_SECTION_DEBUG* PCRITICAL_SECTION_DEBUG;

struct CRITICAL_SECTION {
    PCRITICAL_SECTION_DEBUG DebugInfo;
    LONG   LockCount;
    LONG   RecursionCount;
    HANDLE OwningThread;
    HANDLE LockSemaphore;
    DWORD  SpinCount;
}
alias CRITICAL_SECTION* PCRITICAL_SECTION, LPCRITICAL_SECTION;
*/

alias CRITICAL_SECTION_DEBUG = RTL_CRITICAL_SECTION_DEBUG;
alias PCRITICAL_SECTION_DEBUG = CRITICAL_SECTION_DEBUG*;

alias CRITICAL_SECTION = RTL_CRITICAL_SECTION;
alias PCRITICAL_SECTION = CRITICAL_SECTION*, LPCRITICAL_SECTION = CRITICAL_SECTION*;

struct SYSTEMTIME {
    WORD wYear;
    WORD wMonth;
    WORD wDayOfWeek;
    WORD wDay;
    WORD wHour;
    WORD wMinute;
    WORD wSecond;
    WORD wMilliseconds;
}
alias LPSYSTEMTIME = SYSTEMTIME*;

struct WIN32_FILE_ATTRIBUTE_DATA {
    DWORD    dwFileAttributes;
    FILETIME ftCreationTime;
    FILETIME ftLastAccessTime;
    FILETIME ftLastWriteTime;
    DWORD    nFileSizeHigh;
    DWORD    nFileSizeLow;
}
alias LPWIN32_FILE_ATTRIBUTE_DATA = WIN32_FILE_ATTRIBUTE_DATA*;

struct WIN32_FIND_DATAA {
    DWORD          dwFileAttributes;
    FILETIME       ftCreationTime;
    FILETIME       ftLastAccessTime;
    FILETIME       ftLastWriteTime;
    DWORD          nFileSizeHigh;
    DWORD          nFileSizeLow;
// #ifdef _WIN32_WCE
//  DWORD dwOID;
// #else
    DWORD          dwReserved0;
    DWORD          dwReserved1;
// #endif
    CHAR[MAX_PATH] cFileName = 0;
// #ifndef _WIN32_WCE
    CHAR[14]       cAlternateFileName = 0;
// #endif
}
alias PWIN32_FIND_DATAA = WIN32_FIND_DATAA*, LPWIN32_FIND_DATAA = WIN32_FIND_DATAA*;

struct WIN32_FIND_DATAW {
    DWORD           dwFileAttributes;
    FILETIME        ftCreationTime;
    FILETIME        ftLastAccessTime;
    FILETIME        ftLastWriteTime;
    DWORD           nFileSizeHigh;
    DWORD           nFileSizeLow;
// #ifdef _WIN32_WCE
//  DWORD dwOID;
// #else
    DWORD           dwReserved0;
    DWORD           dwReserved1;
// #endif
    WCHAR[MAX_PATH] cFileName = 0;
// #ifndef _WIN32_WCE
    WCHAR[14]       cAlternateFileName = 0;
// #endif
}
alias PWIN32_FIND_DATAW = WIN32_FIND_DATAW*, LPWIN32_FIND_DATAW = WIN32_FIND_DATAW*;

struct WIN32_STREAM_ID {
    DWORD         dwStreamId;
    DWORD         dwStreamAttributes;
    LARGE_INTEGER Size;
    DWORD         dwStreamNameSize;
    WCHAR         _cStreamName = 0;

    WCHAR* cStreamName() return { return &_cStreamName; }
}
alias LPWIN32_STREAM_ID = WIN32_STREAM_ID*;

static if (_WIN32_WINNT >= 0x601) {
    enum FINDEX_INFO_LEVELS {
        FindExInfoStandard,
        FindExInfoBasic,
        FindExInfoMaxInfoLevel,
    }
} else {
    enum FINDEX_INFO_LEVELS {
        FindExInfoStandard,
        FindExInfoMaxInfoLevel,
    }
}

enum FINDEX_SEARCH_OPS {
    FindExSearchNameMatch,
    FindExSearchLimitToDirectories,
    FindExSearchLimitToDevices,
    FindExSearchMaxSearchOp
}

enum ACL_INFORMATION_CLASS {
    AclRevisionInformation = 1,
    AclSizeInformation
}

struct HW_PROFILE_INFOA {
    DWORD dwDockInfo;
    CHAR[HW_PROFILE_GUIDLEN] szHwProfileGuid = 0;
    CHAR[MAX_PROFILE_LEN]    szHwProfileName = 0;
}
alias LPHW_PROFILE_INFOA = HW_PROFILE_INFOA*;

struct HW_PROFILE_INFOW {
    DWORD dwDockInfo;
    WCHAR[HW_PROFILE_GUIDLEN] szHwProfileGuid = 0;
    WCHAR[MAX_PROFILE_LEN]    szHwProfileName = 0;
}
alias LPHW_PROFILE_INFOW = HW_PROFILE_INFOW*;

/*  ??? MSDN documents this only for Windows CE/Mobile, but it's used by
 *  GetFileAttributesEx, which is in desktop Windows.
 */
enum GET_FILEEX_INFO_LEVELS {
    GetFileExInfoStandard,
    GetFileExMaxInfoLevel
}

import core.sys.windows.sdkddkver : NTDDI_VERSION, NTDDI_LONGHORN;

static if (NTDDI_VERSION >= NTDDI_LONGHORN)
{
    enum FILE_INFO_BY_HANDLE_CLASS
    {
        FileBasicInfo,
        FileStandardInfo,
        FileNameInfo,
        FileRenameInfo,
        FileDispositionInfo,
        FileAllocationInfo,
        FileEndOfFileInfo,
        FileStreamInfo,
        FileCompressionInfo,
        FileAttributeTagInfo,
        FileIdBothDirectoryInfo,
        FileIdBothDirectoryRestartInfo,
        FileIoPriorityHintInfo,
        FileRemoteProtocolInfo,
        FileFullDirectoryInfo,
        FileFullDirectoryRestartInfo,
//        static if (NTDDI_VERSION >= NTDDI_WIN8)
//        {
            FileStorageInfo,
            FileAlignmentInfo,
            FileIdInfo,
            FileIdExtdDirectoryInfo,
            FileIdExtdDirectoryRestartInfo,
//        }
//        static if (NTDDI_VERSION >= NTDDI_WIN10_RS1)
//        {
            FileDispositionInfoEx,
            FileRenameInfoEx,
//        }
//        static if (NTDDI_VERSION >= NTDDI_WIN10_19H1)
//        {
            FileCaseSensitiveInfo,
            FileNormalizedNameInfo,
//        }
        MaximumFileInfoByHandleClass
    }
    alias PFILE_INFO_BY_HANDLE_CLASS = FILE_INFO_BY_HANDLE_CLASS*;
}

struct SYSTEM_INFO {
    union {
        DWORD dwOemId;
        struct {
            WORD wProcessorArchitecture;
            WORD wReserved;
        }
    }
    DWORD dwPageSize;
    PVOID lpMinimumApplicationAddress;
    PVOID lpMaximumApplicationAddress;
    DWORD_PTR dwActiveProcessorMask;
    DWORD dwNumberOfProcessors;
    DWORD dwProcessorType;
    DWORD dwAllocationGranularity;
    WORD  wProcessorLevel;
    WORD  wProcessorRevision;
}
alias LPSYSTEM_INFO = SYSTEM_INFO*;

static if (_WIN32_WINNT >= 0x500) {
    struct SYSTEM_POWER_STATUS {
        BYTE ACLineStatus;
        BYTE BatteryFlag;
        BYTE BatteryLifePercent;
        BYTE Reserved1;
        DWORD BatteryLifeTime;
        DWORD BatteryFullLifeTime;
    }
    alias LPSYSTEM_POWER_STATUS = SYSTEM_POWER_STATUS*;
}

struct TIME_ZONE_INFORMATION {
    LONG       Bias;
    WCHAR[32]  StandardName = 0;
    SYSTEMTIME StandardDate;
    LONG       StandardBias;
    WCHAR[32]  DaylightName = 0;
    SYSTEMTIME DaylightDate;
    LONG       DaylightBias;
}
alias LPTIME_ZONE_INFORMATION = TIME_ZONE_INFORMATION*;

// Does not exist in Windows headers, only MSDN
// documentation (for TIME_ZONE_INFORMATION).
// Provided solely for compatibility with the old
// core.sys.windows.windows
struct REG_TZI_FORMAT {
    LONG Bias;
    LONG StandardBias;
    LONG DaylightBias;
    SYSTEMTIME StandardDate;
    SYSTEMTIME DaylightDate;
}

// MSDN documents this, possibly erroneously, as Win2000+.
struct MEMORYSTATUS {
    DWORD dwLength;
    DWORD dwMemoryLoad;
    SIZE_T dwTotalPhys;
    SIZE_T dwAvailPhys;
    SIZE_T dwTotalPageFile;
    SIZE_T dwAvailPageFile;
    SIZE_T dwTotalVirtual;
    SIZE_T dwAvailVirtual;
}
alias LPMEMORYSTATUS = MEMORYSTATUS*;

static if (_WIN32_WINNT >= 0x500) {
    struct MEMORYSTATUSEX {
        DWORD     dwLength;
        DWORD     dwMemoryLoad;
        DWORDLONG ullTotalPhys;
        DWORDLONG ullAvailPhys;
        DWORDLONG ullTotalPageFile;
        DWORDLONG ullAvailPageFile;
        DWORDLONG ullTotalVirtual;
        DWORDLONG ullAvailVirtual;
        DWORDLONG ullAvailExtendedVirtual;
    }
    alias LPMEMORYSTATUSEX = MEMORYSTATUSEX*;
}

struct LDT_ENTRY {
    WORD LimitLow;
    WORD BaseLow;
    struct {
        BYTE BaseMid;
        BYTE Flags1;
        BYTE Flags2;
        BYTE BaseHi;

        byte Type(byte f)        { Flags1 = cast(BYTE) ((Flags1 & 0xE0) | f); return cast(byte)(f & 0x1F); }
        byte Dpl(byte f)         { Flags1 = cast(BYTE) ((Flags1 & 0x9F) | (f<<5)); return cast(byte)(f & 3); }
        bool Pres(bool f)        { Flags1 = cast(BYTE) ((Flags1 & 0x7F) | (f<<7)); return f; }

        byte LimitHi(byte f)     { Flags2 = cast(BYTE) ((Flags2 & 0xF0) | (f&0x0F)); return cast(byte)(f & 0x0F); }
        bool Sys(bool f)         { Flags2 = cast(BYTE) ((Flags2 & 0xEF) | (f<<4)); return f; }
        // Next bit is reserved
        bool Default_Big(bool f) { Flags2 = cast(BYTE) ((Flags2 & 0xBF) | (f<<6)); return f; }
        bool Granularity(bool f) { Flags2 = cast(BYTE) ((Flags2 & 0x7F) | (f<<7)); return f; }

        byte Type()        { return cast(byte) (Flags1 & 0x1F); }
        byte Dpl()         { return cast(byte) ((Flags1 & 0x60)>>5); }
        bool Pres()        { return cast(bool) (Flags1 & 0x80); }

        byte LimitHi()     { return cast(byte) (Flags2 & 0x0F); }
        bool Sys()         { return cast(bool) (Flags2 & 0x10); }
        bool Default_Big()() { return cast(bool) (Flags2 & 0x40); }
        bool Granularity()() { return cast(bool) (Flags2 & 0x80); }
    }
/+
    union  HighWord {
        struct Bytes {
            BYTE BaseMid;
            BYTE Flags1;
            BYTE Flags2;
            BYTE BaseHi;
        }
    struct Bits {
        DWORD BaseMid:8;
        DWORD Type:5;
        DWORD Dpl:2;
        DWORD Pres:1;
        DWORD LimitHi:4;
        DWORD Sys:1;
        DWORD Reserved_0:1;
        DWORD Default_Big:1;
        DWORD Granularity:1;
        DWORD BaseHi:8;
    }
    }
+/
}
alias PLDT_ENTRY = LDT_ENTRY*, LPLDT_ENTRY = LDT_ENTRY*;

/*  As with the other memory management functions and structures, MSDN's
 *  Windows version info shall be taken with a cup of salt.
 */
struct PROCESS_HEAP_ENTRY {
    PVOID lpData;
    DWORD cbData;
    BYTE  cbOverhead;
    BYTE  iRegionIndex;
    WORD  wFlags;
    union {
        struct _Block {
            HANDLE   hMem;
            DWORD[3] dwReserved;
        }
        _Block Block;
        struct _Region {
            DWORD    dwCommittedSize;
            DWORD    dwUnCommittedSize;
            LPVOID   lpFirstBlock;
            LPVOID   lpLastBlock;
        }
        _Region Region;
    }
}
alias LPPROCESS_HEAP_ENTRY = PROCESS_HEAP_ENTRY*;

struct OFSTRUCT {
    BYTE      cBytes = OFSTRUCT.sizeof;
    BYTE      fFixedDisk;
    WORD      nErrCode;
    WORD      Reserved1;
    WORD      Reserved2;
    CHAR[128] szPathName = 0; // const OFS_MAXPATHNAME = 128;
}
alias LPOFSTRUCT = OFSTRUCT*, POFSTRUCT = OFSTRUCT*;

/*  ??? MSDN documents this only for Windows CE, but it's used by
 *  ImageGetCertificateData, which is in desktop Windows.
 */
struct WIN_CERTIFICATE {
    DWORD dwLength;
    WORD  wRevision;
    WORD  wCertificateType;
    BYTE  _bCertificate;

    BYTE* bCertificate() return { return &_bCertificate; }
}
alias LPWIN_CERTIFICATE = WIN_CERTIFICATE*;

static if (_WIN32_WINNT >= 0x500) {
    enum COMPUTER_NAME_FORMAT {
        ComputerNameNetBIOS,
        ComputerNameDnsHostname,
        ComputerNameDnsDomain,
        ComputerNameDnsFullyQualified,
        ComputerNamePhysicalNetBIOS,
        ComputerNamePhysicalDnsHostname,
        ComputerNamePhysicalDnsDomain,
        ComputerNamePhysicalDnsFullyQualified,
        ComputerNameMax
    }
}

static if (_WIN32_WINNT >= 0x501) {
    struct ACTCTXA {
        ULONG cbSize = this.sizeof;
        DWORD dwFlags;
        LPCSTR lpSource;
        USHORT wProcessorArchitecture;
        LANGID wLangId;
        LPCSTR lpAssemblyDirectory;
        LPCSTR lpResourceName;
        LPCSTR lpApplicationName;
        HMODULE hModule;
    }
    alias PACTCTXA = ACTCTXA*;
    alias PCACTCTXA = const(ACTCTXA)*;

    struct ACTCTXW {
        ULONG cbSize = this.sizeof;
        DWORD dwFlags;
        LPCWSTR lpSource;
        USHORT wProcessorArchitecture;
        LANGID wLangId;
        LPCWSTR lpAssemblyDirectory;
        LPCWSTR lpResourceName;
        LPCWSTR lpApplicationName;
        HMODULE hModule;
    }
    alias PACTCTXW = ACTCTXW*;
    alias PCACTCTXW = const(ACTCTXW)*;

    struct ACTCTX_SECTION_KEYED_DATA {
        ULONG cbSize = this.sizeof;
        ULONG ulDataFormatVersion;
        PVOID lpData;
        ULONG ulLength;
        PVOID lpSectionGlobalData;
        ULONG ulSectionGlobalDataLength;
        PVOID lpSectionBase;
        ULONG ulSectionTotalLength;
        HANDLE hActCtx;
        HANDLE ulAssemblyRosterIndex;
    }
    alias PACTCTX_SECTION_KEYED_DATA = ACTCTX_SECTION_KEYED_DATA*;
    alias PCACTCTX_SECTION_KEYED_DATA = const(ACTCTX_SECTION_KEYED_DATA)*;

    enum MEMORY_RESOURCE_NOTIFICATION_TYPE {
        LowMemoryResourceNotification,
        HighMemoryResourceNotification
    }

} // (_WIN32_WINNT >= 0x501)

static if (_WIN32_WINNT >= 0x410) {
    /*  apparently used only by SetThreadExecutionState (Win2000+)
     *  and DDK functions (version compatibility not established)
     */
    alias EXECUTION_STATE = DWORD;
}

// CreateSymbolicLink, GetFileInformationByHandleEx
static if (_WIN32_WINNT >= 0x600) {
    enum {
        SYMBOLIC_LINK_FLAG_DIRECTORY = 0x1,
        SYMBOLIC_LINK_FLAG_ALLOW_UNPRIVILEGED_CREATE = 0x2
    }

    struct FILE_BASIC_INFO
    {
        LARGE_INTEGER CreationTime;
        LARGE_INTEGER LastAccessTime;
        LARGE_INTEGER LastWriteTime;
        LARGE_INTEGER ChangeTime;
        DWORD FileAttributes;
    }
    alias PFILE_BASIC_INFO = FILE_BASIC_INFO*;

    struct FILE_STANDARD_INFO
    {
        LARGE_INTEGER AllocationSize;
        LARGE_INTEGER EndOfFile;
        DWORD NumberOfLinks;
        BOOLEAN DeletePending;
        BOOLEAN Directory;
    }
    alias PFILE_STANDARD_INFO = FILE_STANDARD_INFO*;
}

// Callbacks
extern (Windows) {
    alias LPTHREAD_START_ROUTINE = DWORD function(LPVOID);
    alias LPPROGRESS_ROUTINE = DWORD function(LARGE_INTEGER, LARGE_INTEGER, LARGE_INTEGER, LARGE_INTEGER,
        DWORD, DWORD, HANDLE, HANDLE, LPVOID);
    alias LPFIBER_START_ROUTINE = void function(PVOID);

    alias ENUMRESLANGPROCA = BOOL function(HMODULE, LPCSTR, LPCSTR, WORD, LONG_PTR);
    alias ENUMRESLANGPROCW = BOOL function(HMODULE, LPCWSTR, LPCWSTR, WORD, LONG_PTR);
    alias ENUMRESNAMEPROCA = BOOL function(HMODULE, LPCSTR, LPSTR, LONG_PTR);
    alias ENUMRESNAMEPROCW = BOOL function(HMODULE, LPCWSTR, LPWSTR, LONG_PTR);
    alias ENUMRESTYPEPROCA = BOOL function(HMODULE, LPSTR, LONG_PTR);
    alias ENUMRESTYPEPROCW = BOOL function(HMODULE, LPWSTR, LONG_PTR);
    alias LPOVERLAPPED_COMPLETION_ROUTINE = void function(DWORD, DWORD, LPOVERLAPPED);
    alias PTOP_LEVEL_EXCEPTION_FILTER = LONG function(LPEXCEPTION_POINTERS);
    alias LPTOP_LEVEL_EXCEPTION_FILTER = PTOP_LEVEL_EXCEPTION_FILTER;

    alias PAPCFUNC = void function(ULONG_PTR);
    alias PTIMERAPCROUTINE = void function(PVOID, DWORD, DWORD);

    static if (_WIN32_WINNT >= 0x500) {
        alias WAITORTIMERCALLBACK = void function(PVOID, BOOLEAN);
    }
}

LPTSTR MAKEINTATOM()(ushort i) {
    return cast(LPTSTR) cast(size_t) i;
}

extern (Windows) nothrow @nogc {
    // The following Win16 functions are obselete in Win32.
    int _hread(HFILE, LPVOID, int);
    int _hwrite(HFILE, LPCSTR, int);
    HFILE _lclose(HFILE);
    HFILE _lcreat(LPCSTR, int);
    LONG _llseek(HFILE, LONG, int);
    HFILE _lopen(LPCSTR, int);
    UINT _lread(HFILE, LPVOID, UINT);
    UINT _lwrite(HFILE, LPCSTR, UINT);
    SIZE_T GlobalCompact(DWORD);
    VOID GlobalFix(HGLOBAL);

    // MSDN contradicts itself on GlobalFlags:
    // "This function is provided only for compatibility with 16-bit versions of Windows."
    // but also requires Windows 2000 or above
    UINT GlobalFlags(HGLOBAL);
    VOID GlobalUnfix(HGLOBAL);
    BOOL GlobalUnWire(HGLOBAL);
    PVOID GlobalWire(HGLOBAL);
    SIZE_T LocalCompact(UINT);
    UINT LocalFlags(HLOCAL);
    SIZE_T LocalShrink(HLOCAL, UINT);

    /+
    //--------------------------------------
    // These functions are problematic

    version (UseNtoSKernel) {}else {
        /* CAREFUL: These are exported from ntoskrnl.exe and declared in winddk.h
           as __fastcall functions, but are  exported from kernel32.dll as __stdcall */
        static if (_WIN32_WINNT >= 0x501) {
         VOID InitializeSListHead(PSLIST_HEADER);
        }
        LONG InterlockedCompareExchange(LPLONG, LONG, LONG);
        // PVOID WINAPI InterlockedCompareExchangePointer(PVOID*, PVOID, PVOID);
        (PVOID)InterlockedCompareExchange((LPLONG)(d)    (PVOID)InterlockedCompareExchange((LPLONG)(d), (LONG)(e), (LONG)(c))
        LONG InterlockedDecrement(LPLONG);
        LONG InterlockedExchange(LPLONG, LONG);
        // PVOID WINAPI InterlockedExchangePointer(PVOID*, PVOID);
        (PVOID)InterlockedExchange((LPLONG)((PVOID)InterlockedExchange((LPLONG)(t), (LONG)(v))
        LONG InterlockedExchangeAdd(LPLONG, LONG);

        static if (_WIN32_WINNT >= 0x501) {
        PSLIST_ENTRY InterlockedFlushSList(PSLIST_HEADER);
        }
        LONG InterlockedIncrement(LPLONG);
        static if (_WIN32_WINNT >= 0x501) {
        PSLIST_ENTRY InterlockedPopEntrySList(PSLIST_HEADER);
        PSLIST_ENTRY InterlockedPushEntrySList(PSLIST_HEADER, PSLIST_ENTRY);
        }
    } // #endif //  __USE_NTOSKRNL__
    //--------------------------------------
    +/

    LONG InterlockedIncrement(LPLONG lpAddend);
    LONG InterlockedDecrement(LPLONG lpAddend);
    LONG InterlockedExchange(LPLONG Target, LONG Value);
    LONG InterlockedExchangeAdd(LPLONG Addend, LONG Value);
    LONG InterlockedCompareExchange(LONG *Destination, LONG Exchange, LONG Comperand);

    ATOM AddAtomA(LPCSTR);
    ATOM AddAtomW(LPCWSTR);
    BOOL AreFileApisANSI();
    BOOL Beep(DWORD, DWORD);
    HANDLE BeginUpdateResourceA(LPCSTR, BOOL);
    HANDLE BeginUpdateResourceW(LPCWSTR, BOOL);
    BOOL BuildCommDCBA(LPCSTR, LPDCB);
    BOOL BuildCommDCBW(LPCWSTR, LPDCB);
    BOOL BuildCommDCBAndTimeoutsA(LPCSTR, LPDCB, LPCOMMTIMEOUTS);
    BOOL BuildCommDCBAndTimeoutsW(LPCWSTR, LPDCB, LPCOMMTIMEOUTS);
    BOOL CallNamedPipeA(LPCSTR, PVOID, DWORD, PVOID, DWORD, PDWORD, DWORD);
    BOOL CallNamedPipeW(LPCWSTR, PVOID, DWORD, PVOID, DWORD, PDWORD, DWORD);
    BOOL CancelDeviceWakeupRequest(HANDLE);
    BOOL CheckTokenMembership(HANDLE, PSID, PBOOL);
    BOOL ClearCommBreak(HANDLE);
    BOOL ClearCommError(HANDLE, PDWORD, LPCOMSTAT);
    BOOL CloseHandle(HANDLE) @trusted;
    BOOL CommConfigDialogA(LPCSTR, HWND, LPCOMMCONFIG);
    BOOL CommConfigDialogW(LPCWSTR, HWND, LPCOMMCONFIG);
    LONG CompareFileTime(const(FILETIME)*, const(FILETIME)*);
    BOOL ContinueDebugEvent(DWORD, DWORD, DWORD);
    BOOL CopyFileA(LPCSTR, LPCSTR, BOOL);
    BOOL CopyFileW(LPCWSTR, LPCWSTR, BOOL);
    BOOL CopyFileExA(LPCSTR, LPCSTR, LPPROGRESS_ROUTINE, LPVOID, LPBOOL, DWORD);
    BOOL CopyFileExW(LPCWSTR, LPCWSTR, LPPROGRESS_ROUTINE, LPVOID, LPBOOL, DWORD);

    alias RtlMoveMemory = memmove;
    alias RtlCopyMemory = memcpy;
    pragma(inline, true) void RtlFillMemory(PVOID Destination, SIZE_T Length, BYTE Fill) pure { memset(Destination, Fill, Length); }
    pragma(inline, true) void RtlZeroMemory(PVOID Destination, SIZE_T Length) pure { memset(Destination, 0, Length); }
    alias MoveMemory = RtlMoveMemory;
    alias CopyMemory = RtlCopyMemory;
    alias FillMemory = RtlFillMemory;
    alias ZeroMemory = RtlZeroMemory;

    BOOL CreateDirectoryA(LPCSTR, LPSECURITY_ATTRIBUTES);
    BOOL CreateDirectoryW(LPCWSTR, LPSECURITY_ATTRIBUTES);
    BOOL CreateDirectoryExA(LPCSTR, LPCSTR, LPSECURITY_ATTRIBUTES);
    BOOL CreateDirectoryExW(LPCWSTR, LPCWSTR, LPSECURITY_ATTRIBUTES);
    HANDLE CreateEventA(LPSECURITY_ATTRIBUTES, BOOL, BOOL, LPCSTR);
    HANDLE CreateEventW(LPSECURITY_ATTRIBUTES, BOOL, BOOL, LPCWSTR);
    HANDLE CreateFileA(LPCSTR, DWORD, DWORD, LPSECURITY_ATTRIBUTES, DWORD, DWORD, HANDLE);
    HANDLE CreateFileW(LPCWSTR, DWORD, DWORD, LPSECURITY_ATTRIBUTES, DWORD, DWORD, HANDLE);
    HANDLE CreateIoCompletionPort(HANDLE, HANDLE, ULONG_PTR, DWORD);
    HANDLE CreateMailslotA(LPCSTR, DWORD, DWORD, LPSECURITY_ATTRIBUTES);
    HANDLE CreateMailslotW(LPCWSTR, DWORD, DWORD, LPSECURITY_ATTRIBUTES);
    HANDLE CreateMutexA(LPSECURITY_ATTRIBUTES, BOOL, LPCSTR);
    HANDLE CreateMutexW(LPSECURITY_ATTRIBUTES, BOOL, LPCWSTR);
    BOOL CreatePipe(PHANDLE, PHANDLE, LPSECURITY_ATTRIBUTES, DWORD);
    BOOL CreateProcessA(LPCSTR, LPSTR, LPSECURITY_ATTRIBUTES, LPSECURITY_ATTRIBUTES, BOOL, DWORD, PVOID, LPCSTR, LPSTARTUPINFOA, LPPROCESS_INFORMATION);
    BOOL CreateProcessW(LPCWSTR, LPWSTR, LPSECURITY_ATTRIBUTES, LPSECURITY_ATTRIBUTES, BOOL, DWORD, PVOID, LPCWSTR, LPSTARTUPINFOW, LPPROCESS_INFORMATION);
    HANDLE CreateSemaphoreA(LPSECURITY_ATTRIBUTES, LONG, LONG, LPCSTR) @trusted;
    HANDLE CreateSemaphoreW(LPSECURITY_ATTRIBUTES, LONG, LONG, LPCWSTR) @trusted;
    HANDLE CreateThread(LPSECURITY_ATTRIBUTES, SIZE_T, LPTHREAD_START_ROUTINE, PVOID, DWORD, PDWORD);
    BOOL DebugActiveProcess(DWORD);
    void DebugBreak();
    ATOM DeleteAtom(ATOM);
    void DeleteCriticalSection(PCRITICAL_SECTION);
    BOOL DeleteFileA(LPCSTR);
    BOOL DeleteFileW(LPCWSTR);
    BOOL DisableThreadLibraryCalls(HMODULE);
    BOOL DosDateTimeToFileTime(WORD, WORD, LPFILETIME);
    BOOL DuplicateHandle(HANDLE, HANDLE, HANDLE, PHANDLE, DWORD, BOOL, DWORD);
    BOOL EndUpdateResourceA(HANDLE, BOOL);
    BOOL EndUpdateResourceW(HANDLE, BOOL);
    void EnterCriticalSection(LPCRITICAL_SECTION);
    void EnterCriticalSection(shared(CRITICAL_SECTION)*);
    BOOL EnumResourceLanguagesA(HMODULE, LPCSTR, LPCSTR, ENUMRESLANGPROC, LONG_PTR);
    BOOL EnumResourceLanguagesW(HMODULE, LPCWSTR, LPCWSTR, ENUMRESLANGPROC, LONG_PTR);
    BOOL EnumResourceNamesA(HMODULE, LPCSTR, ENUMRESNAMEPROC, LONG_PTR);
    BOOL EnumResourceNamesW(HMODULE, LPCWSTR, ENUMRESNAMEPROC, LONG_PTR);
    BOOL EnumResourceTypesA(HMODULE, ENUMRESTYPEPROC, LONG_PTR);
    BOOL EnumResourceTypesW(HMODULE, ENUMRESTYPEPROC, LONG_PTR);
    BOOL EscapeCommFunction(HANDLE, DWORD);
    void ExitProcess(UINT); // Never returns
    void ExitThread(DWORD); // Never returns
    DWORD ExpandEnvironmentStringsA(LPCSTR, LPSTR, DWORD);
    DWORD ExpandEnvironmentStringsW(LPCWSTR, LPWSTR, DWORD);
    void FatalAppExitA(UINT, LPCSTR);
    void FatalAppExitW(UINT, LPCWSTR);
    void FatalExit(int);
    BOOL FileTimeToDosDateTime(const(FILETIME)*, LPWORD, LPWORD);
    BOOL FileTimeToLocalFileTime(const(FILETIME)*, LPFILETIME);
    BOOL FileTimeToSystemTime(const(FILETIME)*, LPSYSTEMTIME);
    ATOM FindAtomA(LPCSTR);
    ATOM FindAtomW(LPCWSTR);
    BOOL FindClose(HANDLE);
    BOOL FindCloseChangeNotification(HANDLE);
    HANDLE FindFirstChangeNotificationA(LPCSTR, BOOL, DWORD);
    HANDLE FindFirstChangeNotificationW(LPCWSTR, BOOL, DWORD);
    HANDLE FindFirstFileA(LPCSTR, LPWIN32_FIND_DATAA);
    HANDLE FindFirstFileW(LPCWSTR, LPWIN32_FIND_DATAW);
    BOOL FindNextChangeNotification(HANDLE);
    BOOL FindNextFileA(HANDLE, LPWIN32_FIND_DATAA);
    BOOL FindNextFileW(HANDLE, LPWIN32_FIND_DATAW);
    HRSRC FindResourceA(HMODULE, LPCSTR, LPCSTR);
    HRSRC FindResourceW(HINSTANCE, LPCWSTR, LPCWSTR);
    HRSRC FindResourceExA(HINSTANCE, LPCSTR, LPCSTR, WORD);
    HRSRC FindResourceExW(HINSTANCE, LPCWSTR, LPCWSTR, WORD);
    BOOL FlushFileBuffers(HANDLE);
    BOOL FlushInstructionCache(HANDLE, PCVOID, SIZE_T);
    DWORD FormatMessageA(DWORD, PCVOID, DWORD, DWORD, LPSTR, DWORD, va_list*);
    DWORD FormatMessageW(DWORD, PCVOID, DWORD, DWORD, LPWSTR, DWORD, va_list*);
    BOOL FreeEnvironmentStringsA(LPSTR);
    BOOL FreeEnvironmentStringsW(LPWSTR);
    BOOL FreeLibrary(HMODULE);
    void FreeLibraryAndExitThread(HMODULE, DWORD); // never returns
    BOOL FreeResource(HGLOBAL);
    UINT GetAtomNameA(ATOM, LPSTR, int);
    UINT GetAtomNameW(ATOM, LPWSTR, int);
    LPSTR GetCommandLineA();
    LPWSTR GetCommandLineW();
    BOOL GetCommConfig(HANDLE, LPCOMMCONFIG, PDWORD);
    BOOL GetCommMask(HANDLE, PDWORD);
    BOOL GetCommModemStatus(HANDLE, PDWORD);
    BOOL GetCommProperties(HANDLE, LPCOMMPROP);
    BOOL GetCommState(HANDLE, LPDCB);
    BOOL GetCommTimeouts(HANDLE, LPCOMMTIMEOUTS);
    BOOL GetComputerNameA(LPSTR, PDWORD);
    BOOL GetComputerNameW(LPWSTR, PDWORD);
    DWORD GetCurrentDirectoryA(DWORD, LPSTR);
    DWORD GetCurrentDirectoryW(DWORD, LPWSTR);
    HANDLE GetCurrentProcess();
    DWORD GetCurrentProcessId();
    HANDLE GetCurrentThread();
/* In MinGW:
#ifdef _WIN32_WCE
extern DWORD GetCurrentThreadId(void);
#else
WINBASEAPI DWORD WINAPI GetCurrentThreadId(void);
#endif
*/
    DWORD GetCurrentThreadId();

    alias GetCurrentTime = GetTickCount;

    BOOL GetDefaultCommConfigA(LPCSTR, LPCOMMCONFIG, PDWORD);
    BOOL GetDefaultCommConfigW(LPCWSTR, LPCOMMCONFIG, PDWORD);
    BOOL GetDiskFreeSpaceA(LPCSTR, PDWORD, PDWORD, PDWORD, PDWORD);
    BOOL GetDiskFreeSpaceW(LPCWSTR, PDWORD, PDWORD, PDWORD, PDWORD);
    BOOL GetDiskFreeSpaceExA(LPCSTR, PULARGE_INTEGER, PULARGE_INTEGER, PULARGE_INTEGER);
    BOOL GetDiskFreeSpaceExW(LPCWSTR, PULARGE_INTEGER, PULARGE_INTEGER, PULARGE_INTEGER);
    UINT GetDriveTypeA(LPCSTR);
    UINT GetDriveTypeW(LPCWSTR);
    LPSTR GetEnvironmentStringsA();
    LPWSTR GetEnvironmentStringsW();
    DWORD GetEnvironmentVariableA(LPCSTR, LPSTR, DWORD);
    DWORD GetEnvironmentVariableW(LPCWSTR, LPWSTR, DWORD);
    BOOL GetExitCodeProcess(HANDLE, PDWORD);
    BOOL GetExitCodeThread(HANDLE, PDWORD);
    DWORD GetFileAttributesA(LPCSTR);
    DWORD GetFileAttributesW(LPCWSTR);
    BOOL GetFileInformationByHandle(HANDLE, LPBY_HANDLE_FILE_INFORMATION);
    DWORD GetFileSize(HANDLE, PDWORD);
    BOOL GetFileTime(HANDLE, LPFILETIME, LPFILETIME, LPFILETIME);
    DWORD GetFileType(HANDLE);
    DWORD GetFinalPathNameByHandleA(HANDLE, LPSTR, DWORD, DWORD);
    DWORD GetFinalPathNameByHandleW(HANDLE, LPWSTR, DWORD, DWORD);
    DWORD GetFullPathNameA(LPCSTR, DWORD, LPSTR, LPSTR*);
    DWORD GetFullPathNameW(LPCWSTR, DWORD, LPWSTR, LPWSTR*);
    DWORD GetLastError() @trusted;
    void GetLocalTime(LPSYSTEMTIME);
    DWORD GetLogicalDrives();
    DWORD GetLogicalDriveStringsA(DWORD, LPSTR);
    DWORD GetLogicalDriveStringsW(DWORD, LPWSTR);
    BOOL GetMailslotInfo(HANDLE, PDWORD, PDWORD, PDWORD, PDWORD);
    DWORD GetModuleFileNameA(HINSTANCE, LPSTR, DWORD);
    DWORD GetModuleFileNameW(HINSTANCE, LPWSTR, DWORD);
    HMODULE GetModuleHandleA(LPCSTR);
    HMODULE GetModuleHandleW(LPCWSTR);
    BOOL GetNamedPipeHandleStateA(HANDLE, PDWORD, PDWORD, PDWORD, PDWORD, LPSTR, DWORD);
    BOOL GetNamedPipeHandleStateW(HANDLE, PDWORD, PDWORD, PDWORD, PDWORD, LPWSTR, DWORD);
    BOOL GetNamedPipeInfo(HANDLE, PDWORD, PDWORD, PDWORD, PDWORD);
    BOOL GetOverlappedResult(HANDLE, LPOVERLAPPED, PDWORD, BOOL);
    DWORD GetPriorityClass(HANDLE);
    UINT GetPrivateProfileIntA(LPCSTR, LPCSTR, INT, LPCSTR);
    UINT GetPrivateProfileIntW(LPCWSTR, LPCWSTR, INT, LPCWSTR);
    DWORD GetPrivateProfileSectionA(LPCSTR, LPSTR, DWORD, LPCSTR);
    DWORD GetPrivateProfileSectionW(LPCWSTR, LPWSTR, DWORD, LPCWSTR);
    DWORD GetPrivateProfileSectionNamesA(LPSTR, DWORD, LPCSTR);
    DWORD GetPrivateProfileSectionNamesW(LPWSTR, DWORD, LPCWSTR);
    DWORD GetPrivateProfileStringA(LPCSTR, LPCSTR, LPCSTR, LPSTR, DWORD, LPCSTR);
    DWORD GetPrivateProfileStringW(LPCWSTR, LPCWSTR, LPCWSTR, LPWSTR, DWORD, LPCWSTR);
    BOOL GetPrivateProfileStructA(LPCSTR, LPCSTR, LPVOID, UINT, LPCSTR);
    BOOL GetPrivateProfileStructW(LPCWSTR, LPCWSTR, LPVOID, UINT, LPCWSTR);
    FARPROC GetProcAddress(HMODULE, LPCSTR); // 1st param wrongly HINSTANCE in MinGW
    BOOL GetProcessAffinityMask(HANDLE, PDWORD_PTR, PDWORD_PTR);
    DWORD GetProcessVersion(DWORD);
    UINT GetProfileIntA(LPCSTR, LPCSTR, INT);
    UINT GetProfileIntW(LPCWSTR, LPCWSTR, INT);
    DWORD GetProfileSectionA(LPCSTR, LPSTR, DWORD);
    DWORD GetProfileSectionW(LPCWSTR, LPWSTR, DWORD);
    DWORD GetProfileStringA(LPCSTR, LPCSTR, LPCSTR, LPSTR, DWORD);
    DWORD GetProfileStringW(LPCWSTR, LPCWSTR, LPCWSTR, LPWSTR, DWORD);
    DWORD GetShortPathNameA(LPCSTR, LPSTR, DWORD);
    DWORD GetShortPathNameW(LPCWSTR, LPWSTR, DWORD);
    VOID GetStartupInfoA(LPSTARTUPINFOA);
    VOID GetStartupInfoW(LPSTARTUPINFOW);
    HANDLE GetStdHandle(DWORD);
    UINT GetSystemDirectoryA(LPSTR, UINT);
    UINT GetSystemDirectoryW(LPWSTR, UINT);
    VOID GetSystemInfo(LPSYSTEM_INFO);
    VOID GetSystemTime(LPSYSTEMTIME);
    BOOL GetSystemTimeAdjustment(PDWORD, PDWORD, PBOOL);
    void GetSystemTimeAsFileTime(LPFILETIME);
    UINT GetTempFileNameA(LPCSTR, LPCSTR, UINT, LPSTR);
    UINT GetTempFileNameW(LPCWSTR, LPCWSTR, UINT, LPWSTR);
    DWORD GetTempPathA(DWORD, LPSTR);
    DWORD GetTempPathW(DWORD, LPWSTR);
    BOOL GetThreadContext(HANDLE, LPCONTEXT);
    int GetThreadPriority(HANDLE);
    BOOL GetThreadSelectorEntry(HANDLE, DWORD, LPLDT_ENTRY);
    DWORD GetTickCount();
    DWORD GetTimeZoneInformation(LPTIME_ZONE_INFORMATION);
    BOOL GetUserNameA (LPSTR, PDWORD);
    BOOL GetUserNameW(LPWSTR, PDWORD);
    DWORD GetVersion();
    BOOL GetVersionExA(LPOSVERSIONINFOA);
    BOOL GetVersionExW(LPOSVERSIONINFOW);
    BOOL GetVolumeInformationA(LPCSTR, LPSTR, DWORD, PDWORD, PDWORD, PDWORD, LPSTR, DWORD);
    BOOL GetVolumeInformationW(LPCWSTR, LPWSTR, DWORD, PDWORD, PDWORD, PDWORD, LPWSTR, DWORD);
    UINT GetWindowsDirectoryA(LPSTR, UINT);
    UINT GetWindowsDirectoryW(LPWSTR, UINT);
    DWORD GetWindowThreadProcessId(HWND, PDWORD);
    ATOM GlobalAddAtomA(LPCSTR);
    ATOM GlobalAddAtomW(LPCWSTR);
    ATOM GlobalDeleteAtom(ATOM);
    ATOM GlobalFindAtomA(LPCSTR);
    ATOM GlobalFindAtomW(LPCWSTR);
    UINT GlobalGetAtomNameA(ATOM, LPSTR, int);
    UINT GlobalGetAtomNameW(ATOM, LPWSTR, int);

    bool HasOverlappedIoCompleted(LPOVERLAPPED lpOverlapped) {
        return lpOverlapped.Internal != STATUS_PENDING;
    }

    BOOL InitAtomTable(DWORD);
    VOID InitializeCriticalSection(LPCRITICAL_SECTION) @trusted;
    /*  ??? The next two are allegedly obsolete and "supported only for
     *  backward compatibility with the 16-bit Windows API".  Yet the
     *  replacements IsBadReadPtr and IsBadWritePtr are apparently Win2000+
     *  only.  Where's the mistake?
     */
    BOOL IsBadHugeReadPtr(PCVOID, UINT_PTR);
    BOOL IsBadHugeWritePtr(PVOID, UINT_PTR);
    BOOL IsBadReadPtr(PCVOID, UINT_PTR);
    BOOL IsBadStringPtrA(LPCSTR, UINT_PTR);
    BOOL IsBadStringPtrW(LPCWSTR, UINT_PTR);
    BOOL IsBadWritePtr(PVOID, UINT_PTR);
    void LeaveCriticalSection(LPCRITICAL_SECTION);
    void LeaveCriticalSection(shared(CRITICAL_SECTION)*);
    HINSTANCE LoadLibraryA(LPCSTR);
    HINSTANCE LoadLibraryW(LPCWSTR);
    HINSTANCE LoadLibraryExA(LPCSTR, HANDLE, DWORD);
    HINSTANCE LoadLibraryExW(LPCWSTR, HANDLE, DWORD);
    DWORD LoadModule(LPCSTR, PVOID);
    HGLOBAL LoadResource(HINSTANCE, HRSRC);
    BOOL LocalFileTimeToFileTime(const(FILETIME)*, LPFILETIME);
    BOOL LockFile(HANDLE, DWORD, DWORD, DWORD, DWORD);
    PVOID LockResource(HGLOBAL);

    LPSTR lstrcatA(LPSTR, LPCSTR);
    LPWSTR lstrcatW(LPWSTR, LPCWSTR);
    int lstrcmpA(LPCSTR, LPCSTR);
    int lstrcmpiA(LPCSTR, LPCSTR);
    int lstrcmpiW(LPCWSTR, LPCWSTR);
    int lstrcmpW(LPCWSTR, LPCWSTR);
    LPSTR lstrcpyA(LPSTR, LPCSTR);
    LPSTR lstrcpynA(LPSTR, LPCSTR, int);
    LPWSTR lstrcpynW(LPWSTR, LPCWSTR, int);
    LPWSTR lstrcpyW(LPWSTR, LPCWSTR);
    int lstrlenA(LPCSTR);
    int lstrlenW(LPCWSTR);

    BOOL MoveFileA(LPCSTR, LPCSTR);
    BOOL MoveFileW(LPCWSTR, LPCWSTR);
    int MulDiv(int, int, int);
    HANDLE OpenEventA(DWORD, BOOL, LPCSTR);
    HANDLE OpenEventW(DWORD, BOOL, LPCWSTR);
    deprecated HFILE OpenFile(LPCSTR, LPOFSTRUCT, UINT);
    HANDLE OpenMutexA(DWORD, BOOL, LPCSTR);
    HANDLE OpenMutexW(DWORD, BOOL, LPCWSTR);
    HANDLE OpenProcess(DWORD, BOOL, DWORD);
    HANDLE OpenSemaphoreA(DWORD, BOOL, LPCSTR);
    HANDLE OpenSemaphoreW(DWORD, BOOL, LPCWSTR);
    void OutputDebugStringA(LPCSTR);
    void OutputDebugStringW(LPCWSTR);
    BOOL PeekNamedPipe(HANDLE, PVOID, DWORD, PDWORD, PDWORD, PDWORD);
    BOOL PulseEvent(HANDLE);
    BOOL PurgeComm(HANDLE, DWORD);
    BOOL QueryPerformanceCounter(PLARGE_INTEGER);
    BOOL QueryPerformanceFrequency(PLARGE_INTEGER);
    DWORD QueueUserAPC(PAPCFUNC, HANDLE, ULONG_PTR);
    void RaiseException(DWORD, DWORD, DWORD, const(ULONG_PTR)*);
    BOOL ReadFile(HANDLE, PVOID, DWORD, PDWORD, LPOVERLAPPED);
    BOOL ReadFileEx(HANDLE, PVOID, DWORD, LPOVERLAPPED, LPOVERLAPPED_COMPLETION_ROUTINE);
    BOOL ReadProcessMemory(HANDLE, PCVOID, PVOID, SIZE_T, SIZE_T*);
    BOOL ReleaseMutex(HANDLE);
    BOOL ReleaseSemaphore(HANDLE, LONG, LPLONG);
    BOOL RemoveDirectoryA(LPCSTR);
    BOOL RemoveDirectoryW(LPCWSTR);
/* In MinGW:
#ifdef _WIN32_WCE
extern BOOL ResetEvent(HANDLE);
#else
WINBASEAPI BOOL WINAPI ResetEvent(HANDLE);
#endif
*/
    BOOL ResetEvent(HANDLE);
    DWORD ResumeThread(HANDLE);
    DWORD SearchPathA(LPCSTR, LPCSTR, LPCSTR, DWORD, LPSTR, LPSTR*);
    DWORD SearchPathW(LPCWSTR, LPCWSTR, LPCWSTR, DWORD, LPWSTR, LPWSTR*);
    BOOL SetCommBreak(HANDLE);
    BOOL SetCommConfig(HANDLE, LPCOMMCONFIG, DWORD);
    BOOL SetCommMask(HANDLE, DWORD);
    BOOL SetCommState(HANDLE, LPDCB);
    BOOL SetCommTimeouts(HANDLE, LPCOMMTIMEOUTS);
    BOOL SetComputerNameA(LPCSTR);
    BOOL SetComputerNameW(LPCWSTR);
    BOOL SetCurrentDirectoryA(LPCSTR);
    BOOL SetCurrentDirectoryW(LPCWSTR);
    BOOL SetDefaultCommConfigA(LPCSTR, LPCOMMCONFIG, DWORD);
    BOOL SetDefaultCommConfigW(LPCWSTR, LPCOMMCONFIG, DWORD);
    BOOL SetEndOfFile(HANDLE);
    BOOL SetEnvironmentVariableA(LPCSTR, LPCSTR);
    BOOL SetEnvironmentVariableW(LPCWSTR, LPCWSTR);
    UINT SetErrorMode(UINT);
/* In MinGW:
#ifdef _WIN32_WCE
extern BOOL SetEvent(HANDLE);
#else
WINBASEAPI BOOL WINAPI SetEvent(HANDLE);
#endif
*/
    BOOL SetEvent(HANDLE);
    VOID SetFileApisToANSI();
    VOID SetFileApisToOEM();
    BOOL SetFileAttributesA(LPCSTR, DWORD);
    BOOL SetFileAttributesW(LPCWSTR, DWORD);
    DWORD SetFilePointer(HANDLE, LONG, PLONG, DWORD);
    BOOL SetFileTime(HANDLE, const(FILETIME)*, const(FILETIME)*, const(FILETIME)*);
    deprecated UINT SetHandleCount(UINT);
    void SetLastError(DWORD);
    void SetLastErrorEx(DWORD, DWORD);
    BOOL SetLocalTime(const(SYSTEMTIME)*);
    BOOL SetMailslotInfo(HANDLE, DWORD);
    BOOL SetNamedPipeHandleState(HANDLE, PDWORD, PDWORD, PDWORD);
    BOOL SetPriorityClass(HANDLE, DWORD);
    BOOL SetStdHandle(DWORD, HANDLE);
    BOOL SetSystemTime(const(SYSTEMTIME)*);
    DWORD_PTR SetThreadAffinityMask(HANDLE, DWORD_PTR);
    BOOL SetThreadContext(HANDLE, const(CONTEXT)*);
    BOOL SetThreadPriority(HANDLE, int);
    BOOL SetTimeZoneInformation(const(TIME_ZONE_INFORMATION)*);
    LPTOP_LEVEL_EXCEPTION_FILTER SetUnhandledExceptionFilter(LPTOP_LEVEL_EXCEPTION_FILTER);
    BOOL SetupComm(HANDLE, DWORD, DWORD);
    BOOL SetVolumeLabelA(LPCSTR, LPCSTR);
    BOOL SetVolumeLabelW(LPCWSTR, LPCWSTR);

    DWORD SizeofResource(HINSTANCE, HRSRC);
    void Sleep(DWORD);
    DWORD SleepEx(DWORD, BOOL);
    DWORD SuspendThread(HANDLE);
    BOOL SystemTimeToFileTime(const(SYSTEMTIME)*, LPFILETIME);
    BOOL TerminateProcess(HANDLE, UINT);
    BOOL TerminateThread(HANDLE, DWORD);
    DWORD TlsAlloc();
    BOOL TlsFree(DWORD);
    PVOID TlsGetValue(DWORD);
    BOOL TlsSetValue(DWORD, PVOID);
    BOOL TransactNamedPipe(HANDLE, PVOID, DWORD, PVOID, DWORD, PDWORD, LPOVERLAPPED);
    BOOL TransmitCommChar(HANDLE, char);
    LONG UnhandledExceptionFilter(LPEXCEPTION_POINTERS);
    BOOL UnlockFile(HANDLE, DWORD, DWORD, DWORD, DWORD);
    BOOL WaitCommEvent(HANDLE, PDWORD, LPOVERLAPPED);
    BOOL WaitForDebugEvent(LPDEBUG_EVENT, DWORD);
    DWORD WaitForMultipleObjects(DWORD, const(HANDLE)*, BOOL, DWORD);
    DWORD WaitForMultipleObjectsEx(DWORD, const(HANDLE)*, BOOL, DWORD, BOOL);
    DWORD WaitForSingleObject(HANDLE, DWORD);
    DWORD WaitForSingleObjectEx(HANDLE, DWORD, BOOL);
    BOOL WaitNamedPipeA(LPCSTR, DWORD);
    BOOL WaitNamedPipeW(LPCWSTR, DWORD);
    // undocumented on MSDN
    BOOL WinLoadTrustProvider(GUID*);
    BOOL WriteFile(HANDLE, PCVOID, DWORD, PDWORD, LPOVERLAPPED);
    BOOL WriteFileEx(HANDLE, PCVOID, DWORD, LPOVERLAPPED, LPOVERLAPPED_COMPLETION_ROUTINE);
    BOOL WritePrivateProfileSectionA(LPCSTR, LPCSTR, LPCSTR);
    BOOL WritePrivateProfileSectionW(LPCWSTR, LPCWSTR, LPCWSTR);
    BOOL WritePrivateProfileStringA(LPCSTR, LPCSTR, LPCSTR, LPCSTR);
    BOOL WritePrivateProfileStringW(LPCWSTR, LPCWSTR, LPCWSTR, LPCWSTR);
    BOOL WritePrivateProfileStructA(LPCSTR, LPCSTR, LPVOID, UINT, LPCSTR);
    BOOL WritePrivateProfileStructW(LPCWSTR, LPCWSTR, LPVOID, UINT, LPCWSTR);
    BOOL WriteProcessMemory(HANDLE, LPVOID, LPCVOID, SIZE_T, SIZE_T*);
    BOOL WriteProfileSectionA(LPCSTR, LPCSTR);
    BOOL WriteProfileSectionW(LPCWSTR, LPCWSTR);
    BOOL WriteProfileStringA(LPCSTR, LPCSTR, LPCSTR);
    BOOL WriteProfileStringW(LPCWSTR, LPCWSTR, LPCWSTR);

    /*  Memory allocation functions.
     *  MSDN documents these erroneously as Win2000+; thus it is uncertain what
     *  version compatibility they really have.
     */
    HGLOBAL GlobalAlloc(UINT, SIZE_T);
    HGLOBAL GlobalDiscard(HGLOBAL);
    HGLOBAL GlobalFree(HGLOBAL);
    HGLOBAL GlobalHandle(PCVOID);
    LPVOID GlobalLock(HGLOBAL);
    VOID GlobalMemoryStatus(LPMEMORYSTATUS);
    HGLOBAL GlobalReAlloc(HGLOBAL, SIZE_T, UINT);
    SIZE_T GlobalSize(HGLOBAL);
    BOOL GlobalUnlock(HGLOBAL);
    PVOID HeapAlloc(HANDLE, DWORD, SIZE_T);
    SIZE_T HeapCompact(HANDLE, DWORD);
    HANDLE HeapCreate(DWORD, SIZE_T, SIZE_T);
    BOOL HeapDestroy(HANDLE);
    BOOL HeapFree(HANDLE, DWORD, PVOID);
    BOOL HeapLock(HANDLE);
    PVOID HeapReAlloc(HANDLE, DWORD, PVOID, SIZE_T);
    SIZE_T HeapSize(HANDLE, DWORD, PCVOID);
    BOOL HeapUnlock(HANDLE);
    BOOL HeapValidate(HANDLE, DWORD, PCVOID);
    BOOL HeapWalk(HANDLE, LPPROCESS_HEAP_ENTRY);
    HLOCAL LocalAlloc(UINT, SIZE_T);
    HLOCAL LocalDiscard(HLOCAL);
    HLOCAL LocalFree(HLOCAL);
    HLOCAL LocalHandle(LPCVOID);
    PVOID LocalLock(HLOCAL);
    HLOCAL LocalReAlloc(HLOCAL, SIZE_T, UINT);
    SIZE_T LocalSize(HLOCAL);
    BOOL LocalUnlock(HLOCAL);
    PVOID VirtualAlloc(PVOID, SIZE_T, DWORD, DWORD);
    PVOID VirtualAllocEx(HANDLE, PVOID, SIZE_T, DWORD, DWORD);
    BOOL VirtualFree(PVOID, SIZE_T, DWORD);
    BOOL VirtualFreeEx(HANDLE, PVOID, SIZE_T, DWORD);
    BOOL VirtualLock(PVOID, SIZE_T);
    BOOL VirtualProtect(PVOID, SIZE_T, DWORD, PDWORD);
    BOOL VirtualProtectEx(HANDLE, PVOID, SIZE_T, DWORD, PDWORD);
    SIZE_T VirtualQuery(LPCVOID, PMEMORY_BASIC_INFORMATION, SIZE_T);
    SIZE_T VirtualQueryEx(HANDLE, LPCVOID, PMEMORY_BASIC_INFORMATION, SIZE_T);
    BOOL VirtualUnlock(PVOID, SIZE_T);
// not in MinGW 4.0 - ???
    static if (_WIN32_WINNT >= 0x600) {
        BOOL CancelIoEx(HANDLE, LPOVERLAPPED);
    }

    BOOL CancelIo(HANDLE);
    BOOL CancelWaitableTimer(HANDLE);
    PVOID ConvertThreadToFiber(PVOID);
    LPVOID CreateFiber(SIZE_T, LPFIBER_START_ROUTINE, LPVOID);
    HANDLE CreateWaitableTimerA(LPSECURITY_ATTRIBUTES, BOOL, LPCSTR);
    HANDLE CreateWaitableTimerW(LPSECURITY_ATTRIBUTES, BOOL, LPCWSTR);
    void DeleteFiber(PVOID);
    BOOL GetFileAttributesExA(LPCSTR, GET_FILEEX_INFO_LEVELS, PVOID);
    BOOL GetFileAttributesExW(LPCWSTR, GET_FILEEX_INFO_LEVELS, PVOID);
    DWORD GetLongPathNameA(LPCSTR, LPSTR, DWORD);
    DWORD GetLongPathNameW(LPCWSTR, LPWSTR, DWORD);
    BOOL InitializeCriticalSectionAndSpinCount(LPCRITICAL_SECTION, DWORD);
    BOOL IsDebuggerPresent();
    HANDLE OpenWaitableTimerA(DWORD, BOOL, LPCSTR);
    HANDLE OpenWaitableTimerW(DWORD, BOOL, LPCWSTR);
    DWORD QueryDosDeviceA(LPCSTR, LPSTR, DWORD);
    DWORD QueryDosDeviceW(LPCWSTR, LPWSTR, DWORD);
    BOOL SetWaitableTimer(HANDLE, const(LARGE_INTEGER)*, LONG, PTIMERAPCROUTINE, PVOID, BOOL);
    void SwitchToFiber(PVOID);

    static if (_WIN32_WINNT >= 0x500) {
        HANDLE OpenThread(DWORD, BOOL, DWORD);
    }

    BOOL AccessCheck(PSECURITY_DESCRIPTOR, HANDLE, DWORD, PGENERIC_MAPPING, PPRIVILEGE_SET, PDWORD, PDWORD, PBOOL);
    BOOL AccessCheckAndAuditAlarmA(LPCSTR, LPVOID, LPSTR, LPSTR, PSECURITY_DESCRIPTOR, DWORD, PGENERIC_MAPPING, BOOL, PDWORD, PBOOL, PBOOL);
    BOOL AccessCheckAndAuditAlarmW(LPCWSTR, LPVOID, LPWSTR, LPWSTR, PSECURITY_DESCRIPTOR, DWORD, PGENERIC_MAPPING, BOOL, PDWORD, PBOOL, PBOOL);
    BOOL AddAccessAllowedAce(PACL, DWORD, DWORD, PSID);
    BOOL AddAccessDeniedAce(PACL, DWORD, DWORD, PSID);
    BOOL AddAce(PACL, DWORD, DWORD, PVOID, DWORD);
    BOOL AddAuditAccessAce(PACL, DWORD, DWORD, PSID, BOOL, BOOL);
    BOOL AdjustTokenGroups(HANDLE, BOOL, PTOKEN_GROUPS, DWORD, PTOKEN_GROUPS, PDWORD);
    BOOL AdjustTokenPrivileges(HANDLE, BOOL, PTOKEN_PRIVILEGES, DWORD, PTOKEN_PRIVILEGES, PDWORD);
    BOOL AllocateAndInitializeSid(PSID_IDENTIFIER_AUTHORITY, BYTE, DWORD, DWORD, DWORD, DWORD, DWORD, DWORD, DWORD, DWORD, PSID*);
    BOOL AllocateLocallyUniqueId(PLUID);
    BOOL AreAllAccessesGranted(DWORD, DWORD);
    BOOL AreAnyAccessesGranted(DWORD, DWORD);
    BOOL BackupEventLogA(HANDLE, LPCSTR);
    BOOL BackupEventLogW(HANDLE, LPCWSTR);
    BOOL BackupRead(HANDLE, LPBYTE, DWORD, LPDWORD, BOOL, BOOL, LPVOID*);
    BOOL BackupSeek(HANDLE, DWORD, DWORD, LPDWORD, LPDWORD, LPVOID*);
    BOOL BackupWrite(HANDLE, LPBYTE, DWORD, LPDWORD, BOOL, BOOL, LPVOID*);
    BOOL ClearEventLogA(HANDLE, LPCSTR);
    BOOL ClearEventLogW(HANDLE, LPCWSTR);
    BOOL CloseEventLog(HANDLE);
    BOOL ConnectNamedPipe(HANDLE, LPOVERLAPPED);
    BOOL CopySid(DWORD, PSID, PSID);
    HANDLE CreateNamedPipeA(LPCSTR, DWORD, DWORD, DWORD, DWORD, DWORD, DWORD, LPSECURITY_ATTRIBUTES);
    HANDLE CreateNamedPipeW(LPCWSTR, DWORD, DWORD, DWORD, DWORD, DWORD, DWORD, LPSECURITY_ATTRIBUTES);
    BOOL CreatePrivateObjectSecurity(PSECURITY_DESCRIPTOR, PSECURITY_DESCRIPTOR, PSECURITY_DESCRIPTOR*, BOOL, HANDLE, PGENERIC_MAPPING);
    BOOL CreateProcessAsUserA(HANDLE, LPCSTR, LPSTR, LPSECURITY_ATTRIBUTES, LPSECURITY_ATTRIBUTES, BOOL, DWORD, PVOID, LPCSTR, LPSTARTUPINFOA, LPPROCESS_INFORMATION);
    BOOL CreateProcessAsUserW(HANDLE, LPCWSTR, LPWSTR, LPSECURITY_ATTRIBUTES, LPSECURITY_ATTRIBUTES, BOOL, DWORD, PVOID, LPCWSTR, LPSTARTUPINFOW, LPPROCESS_INFORMATION);
    HANDLE CreateRemoteThread(HANDLE, LPSECURITY_ATTRIBUTES, SIZE_T, LPTHREAD_START_ROUTINE, LPVOID, DWORD, LPDWORD);
    DWORD CreateTapePartition(HANDLE, DWORD, DWORD, DWORD);
    BOOL DefineDosDeviceA(DWORD, LPCSTR, LPCSTR);
    BOOL DefineDosDeviceW(DWORD, LPCWSTR, LPCWSTR);
    BOOL DeleteAce(PACL, DWORD);
    BOOL DeregisterEventSource(HANDLE);
    BOOL DestroyPrivateObjectSecurity(PSECURITY_DESCRIPTOR*);
    BOOL DeviceIoControl(HANDLE, DWORD, PVOID, DWORD, PVOID, DWORD, PDWORD, POVERLAPPED);
    BOOL DisconnectNamedPipe(HANDLE);
    BOOL DuplicateToken(HANDLE, SECURITY_IMPERSONATION_LEVEL, PHANDLE);
    BOOL DuplicateTokenEx(HANDLE, DWORD, LPSECURITY_ATTRIBUTES, SECURITY_IMPERSONATION_LEVEL, TOKEN_TYPE, PHANDLE);
    BOOL EqualPrefixSid(PSID, PSID);
    BOOL EqualSid(PSID, PSID);
    DWORD EraseTape(HANDLE, DWORD, BOOL);
    HANDLE FindFirstFileExA(LPCSTR, FINDEX_INFO_LEVELS, PVOID, FINDEX_SEARCH_OPS, PVOID, DWORD);
    HANDLE FindFirstFileExW(LPCWSTR, FINDEX_INFO_LEVELS, PVOID, FINDEX_SEARCH_OPS, PVOID, DWORD);
    BOOL FindFirstFreeAce(PACL, PVOID*);
    PVOID FreeSid(PSID);
    BOOL GetAce(PACL, DWORD, LPVOID*);
    BOOL GetAclInformation(PACL, PVOID, DWORD, ACL_INFORMATION_CLASS);
    BOOL GetBinaryTypeA(LPCSTR, PDWORD);
    BOOL GetBinaryTypeW(LPCWSTR, PDWORD);
    DWORD GetCompressedFileSizeA(LPCSTR, PDWORD);
    DWORD GetCompressedFileSizeW(LPCWSTR, PDWORD);
    BOOL GetCurrentHwProfileA(LPHW_PROFILE_INFOA);
    BOOL GetCurrentHwProfileW(LPHW_PROFILE_INFOW);
    BOOL GetFileSecurityA(LPCSTR, SECURITY_INFORMATION, PSECURITY_DESCRIPTOR, DWORD, PDWORD);
    BOOL GetFileSecurityW(LPCWSTR, SECURITY_INFORMATION, PSECURITY_DESCRIPTOR, DWORD, PDWORD);
    BOOL GetHandleInformation(HANDLE, PDWORD);
    BOOL GetKernelObjectSecurity(HANDLE, SECURITY_INFORMATION, PSECURITY_DESCRIPTOR, DWORD, PDWORD);
    DWORD GetLengthSid(PSID);
    BOOL GetNumberOfEventLogRecords(HANDLE, PDWORD);
    BOOL GetOldestEventLogRecord(HANDLE, PDWORD);
    BOOL GetPrivateObjectSecurity(PSECURITY_DESCRIPTOR, SECURITY_INFORMATION, PSECURITY_DESCRIPTOR, DWORD, PDWORD);
    BOOL GetProcessPriorityBoost(HANDLE, PBOOL);
    BOOL GetProcessShutdownParameters(PDWORD, PDWORD);
    BOOL GetProcessTimes(HANDLE, LPFILETIME, LPFILETIME, LPFILETIME, LPFILETIME);
    HWINSTA GetProcessWindowStation();
    BOOL GetProcessWorkingSetSize(HANDLE, PSIZE_T, PSIZE_T);
    BOOL GetQueuedCompletionStatus(HANDLE, PDWORD, PULONG_PTR, LPOVERLAPPED*, DWORD);
    BOOL GetSecurityDescriptorControl(PSECURITY_DESCRIPTOR, PSECURITY_DESCRIPTOR_CONTROL, PDWORD);
    BOOL GetSecurityDescriptorDacl(PSECURITY_DESCRIPTOR, LPBOOL, PACL*, LPBOOL);
    BOOL GetSecurityDescriptorGroup(PSECURITY_DESCRIPTOR, PSID*, LPBOOL);
    DWORD GetSecurityDescriptorLength(PSECURITY_DESCRIPTOR);
    BOOL GetSecurityDescriptorOwner(PSECURITY_DESCRIPTOR, PSID*, LPBOOL);
    BOOL GetSecurityDescriptorSacl(PSECURITY_DESCRIPTOR, LPBOOL, PACL*, LPBOOL);
    PSID_IDENTIFIER_AUTHORITY GetSidIdentifierAuthority(PSID);
    DWORD GetSidLengthRequired(UCHAR);
    PDWORD GetSidSubAuthority(PSID, DWORD);
    PUCHAR GetSidSubAuthorityCount(PSID);
    DWORD GetTapeParameters(HANDLE, DWORD, PDWORD, PVOID);
    DWORD GetTapePosition(HANDLE, DWORD, PDWORD, PDWORD, PDWORD);
    DWORD GetTapeStatus(HANDLE);
    BOOL GetThreadPriorityBoost(HANDLE, PBOOL);
    BOOL GetThreadTimes(HANDLE, LPFILETIME, LPFILETIME, LPFILETIME, LPFILETIME);
    BOOL GetTokenInformation(HANDLE, TOKEN_INFORMATION_CLASS, PVOID, DWORD, PDWORD);
    BOOL ImpersonateLoggedOnUser(HANDLE);
    BOOL ImpersonateNamedPipeClient(HANDLE);
    BOOL ImpersonateSelf(SECURITY_IMPERSONATION_LEVEL);
    BOOL InitializeAcl(PACL, DWORD, DWORD);
    DWORD SetCriticalSectionSpinCount(LPCRITICAL_SECTION, DWORD);
    BOOL InitializeSecurityDescriptor(PSECURITY_DESCRIPTOR, DWORD);
    BOOL InitializeSid(PSID, PSID_IDENTIFIER_AUTHORITY, BYTE);
    BOOL IsProcessorFeaturePresent(DWORD);
    BOOL IsTextUnicode(PCVOID, int, LPINT);
    BOOL IsValidAcl(PACL);
    BOOL IsValidSecurityDescriptor(PSECURITY_DESCRIPTOR);
    BOOL IsValidSid(PSID);
    BOOL CreateWellKnownSid(WELL_KNOWN_SID_TYPE, PSID, PSID, PDWORD);
    BOOL LockFileEx(HANDLE, DWORD, DWORD, DWORD, DWORD, LPOVERLAPPED);
    BOOL LogonUserA(LPSTR, LPSTR, LPSTR, DWORD, DWORD, PHANDLE);
    BOOL LogonUserW(LPWSTR, LPWSTR, LPWSTR, DWORD, DWORD, PHANDLE);
    BOOL LookupAccountNameA(LPCSTR, LPCSTR, PSID, PDWORD, LPSTR, PDWORD, PSID_NAME_USE);
    BOOL LookupAccountNameW(LPCWSTR, LPCWSTR, PSID, PDWORD, LPWSTR, PDWORD, PSID_NAME_USE);
    BOOL LookupAccountSidA(LPCSTR, PSID, LPSTR, PDWORD, LPSTR, PDWORD, PSID_NAME_USE);
    BOOL LookupAccountSidW(LPCWSTR, PSID, LPWSTR, PDWORD, LPWSTR, PDWORD, PSID_NAME_USE);
    BOOL LookupPrivilegeDisplayNameA(LPCSTR, LPCSTR, LPSTR, PDWORD, PDWORD);
    BOOL LookupPrivilegeDisplayNameW(LPCWSTR, LPCWSTR, LPWSTR, PDWORD, PDWORD);
    BOOL LookupPrivilegeNameA(LPCSTR, PLUID, LPSTR, PDWORD);
    BOOL LookupPrivilegeNameW(LPCWSTR, PLUID, LPWSTR, PDWORD);
    BOOL LookupPrivilegeValueA(LPCSTR, LPCSTR, PLUID);
    BOOL LookupPrivilegeValueW(LPCWSTR, LPCWSTR, PLUID);
    BOOL MakeAbsoluteSD(PSECURITY_DESCRIPTOR, PSECURITY_DESCRIPTOR, PDWORD, PACL, PDWORD, PACL, PDWORD, PSID, PDWORD, PSID, PDWORD);
    BOOL MakeSelfRelativeSD(PSECURITY_DESCRIPTOR, PSECURITY_DESCRIPTOR, PDWORD);
    VOID MapGenericMask(PDWORD, PGENERIC_MAPPING);
    BOOL MoveFileExA(LPCSTR, LPCSTR, DWORD);
    BOOL MoveFileExW(LPCWSTR, LPCWSTR, DWORD);
    BOOL NotifyChangeEventLog(HANDLE, HANDLE);
    BOOL ObjectCloseAuditAlarmA(LPCSTR, PVOID, BOOL);
    BOOL ObjectCloseAuditAlarmW(LPCWSTR, PVOID, BOOL);
    BOOL ObjectDeleteAuditAlarmA(LPCSTR, PVOID, BOOL);
    BOOL ObjectDeleteAuditAlarmW(LPCWSTR, PVOID, BOOL);
    BOOL ObjectOpenAuditAlarmA(LPCSTR, PVOID, LPSTR, LPSTR, PSECURITY_DESCRIPTOR, HANDLE, DWORD, DWORD, PPRIVILEGE_SET, BOOL, BOOL, PBOOL);
    BOOL ObjectOpenAuditAlarmW(LPCWSTR, PVOID, LPWSTR, LPWSTR, PSECURITY_DESCRIPTOR, HANDLE, DWORD, DWORD, PPRIVILEGE_SET, BOOL, BOOL, PBOOL);
    BOOL ObjectPrivilegeAuditAlarmA(LPCSTR, PVOID, HANDLE, DWORD, PPRIVILEGE_SET, BOOL);
    BOOL ObjectPrivilegeAuditAlarmW(LPCWSTR, PVOID, HANDLE, DWORD, PPRIVILEGE_SET, BOOL);
    HANDLE OpenBackupEventLogA(LPCSTR, LPCSTR);
    HANDLE OpenBackupEventLogW(LPCWSTR, LPCWSTR);
    HANDLE OpenEventLogA(LPCSTR, LPCSTR);
    HANDLE OpenEventLogW(LPCWSTR, LPCWSTR);
    BOOL OpenProcessToken(HANDLE, DWORD, PHANDLE);
    BOOL OpenThreadToken(HANDLE, DWORD, BOOL, PHANDLE);
    BOOL PostQueuedCompletionStatus(HANDLE, DWORD, ULONG_PTR, LPOVERLAPPED);
    DWORD PrepareTape(HANDLE, DWORD, BOOL);
    BOOL PrivilegeCheck(HANDLE, PPRIVILEGE_SET, PBOOL);
    BOOL PrivilegedServiceAuditAlarmA(LPCSTR, LPCSTR, HANDLE, PPRIVILEGE_SET, BOOL);
    BOOL PrivilegedServiceAuditAlarmW(LPCWSTR, LPCWSTR, HANDLE, PPRIVILEGE_SET, BOOL);
    BOOL ReadDirectoryChangesW(HANDLE, PVOID, DWORD, BOOL, DWORD, PDWORD, LPOVERLAPPED, LPOVERLAPPED_COMPLETION_ROUTINE);
    BOOL ReadEventLogA(HANDLE, DWORD, DWORD, PVOID, DWORD, DWORD*, DWORD*);
    BOOL ReadEventLogW(HANDLE, DWORD, DWORD, PVOID, DWORD, DWORD*, DWORD*);
    BOOL ReadFileScatter(HANDLE, FILE_SEGMENT_ELEMENT*, DWORD, LPDWORD, LPOVERLAPPED);
    HANDLE RegisterEventSourceA (LPCSTR, LPCSTR);
    HANDLE RegisterEventSourceW(LPCWSTR, LPCWSTR);
    BOOL ReportEventA(HANDLE, WORD, WORD, DWORD, PSID, WORD, DWORD, LPCSTR*, PVOID);
    BOOL ReportEventW(HANDLE, WORD, WORD, DWORD, PSID, WORD, DWORD, LPCWSTR*, PVOID);
    BOOL RevertToSelf();
    BOOL SetAclInformation(PACL, PVOID, DWORD, ACL_INFORMATION_CLASS);
    BOOL SetFileSecurityA(LPCSTR, SECURITY_INFORMATION, PSECURITY_DESCRIPTOR);
    BOOL SetFileSecurityW(LPCWSTR, SECURITY_INFORMATION, PSECURITY_DESCRIPTOR);
    BOOL SetHandleInformation(HANDLE, DWORD, DWORD);
    BOOL SetKernelObjectSecurity(HANDLE, SECURITY_INFORMATION, PSECURITY_DESCRIPTOR);
    BOOL SetPrivateObjectSecurity(SECURITY_INFORMATION, PSECURITY_DESCRIPTOR, PSECURITY_DESCRIPTOR*, PGENERIC_MAPPING, HANDLE);
    BOOL SetProcessAffinityMask(HANDLE, DWORD_PTR);
    BOOL SetProcessPriorityBoost(HANDLE, BOOL);
    BOOL SetProcessShutdownParameters(DWORD, DWORD);
    BOOL SetProcessWorkingSetSize(HANDLE, SIZE_T, SIZE_T);
    BOOL SetSecurityDescriptorDacl(PSECURITY_DESCRIPTOR, BOOL, PACL, BOOL);
    BOOL SetSecurityDescriptorGroup(PSECURITY_DESCRIPTOR, PSID, BOOL);
    BOOL SetSecurityDescriptorOwner(PSECURITY_DESCRIPTOR, PSID, BOOL);
    BOOL SetSecurityDescriptorSacl(PSECURITY_DESCRIPTOR, BOOL, PACL, BOOL);
    BOOL SetSystemTimeAdjustment(DWORD, BOOL);
    DWORD SetTapeParameters(HANDLE, DWORD, PVOID);
    DWORD SetTapePosition(HANDLE, DWORD, DWORD, DWORD, DWORD, BOOL);
    BOOL SetThreadPriorityBoost(HANDLE, BOOL);
    BOOL SetThreadToken(PHANDLE, HANDLE);
    BOOL SetTokenInformation(HANDLE, TOKEN_INFORMATION_CLASS, PVOID, DWORD);
    DWORD SignalObjectAndWait(HANDLE, HANDLE, DWORD, BOOL);
    BOOL SwitchToThread();
    BOOL SystemTimeToTzSpecificLocalTime(LPTIME_ZONE_INFORMATION, LPSYSTEMTIME, LPSYSTEMTIME);
    BOOL TzSpecificLocalTimeToSystemTime(LPTIME_ZONE_INFORMATION, LPSYSTEMTIME, LPSYSTEMTIME);
    BOOL TryEnterCriticalSection(LPCRITICAL_SECTION);
    BOOL TryEnterCriticalSection(shared(CRITICAL_SECTION)*);
    BOOL UnlockFileEx(HANDLE, DWORD, DWORD, DWORD, LPOVERLAPPED);
    BOOL UpdateResourceA(HANDLE, LPCSTR, LPCSTR, WORD, PVOID, DWORD);
    BOOL UpdateResourceW(HANDLE, LPCWSTR, LPCWSTR, WORD, PVOID, DWORD);
    BOOL WriteFileGather(HANDLE, FILE_SEGMENT_ELEMENT*, DWORD, LPDWORD, LPOVERLAPPED);
    DWORD WriteTapemark(HANDLE, DWORD, DWORD, BOOL);

    static if (_WIN32_WINNT >= 0x500) {
        BOOL AddAccessAllowedAceEx(PACL, DWORD, DWORD, DWORD, PSID);
        BOOL AddAccessDeniedAceEx(PACL, DWORD, DWORD, DWORD, PSID);
        PVOID AddVectoredExceptionHandler(ULONG, PVECTORED_EXCEPTION_HANDLER);
        BOOL AllocateUserPhysicalPages(HANDLE, PULONG_PTR, PULONG_PTR);
        BOOL AssignProcessToJobObject(HANDLE, HANDLE);
        BOOL ChangeTimerQueueTimer(HANDLE,HANDLE,ULONG,ULONG);
        LPVOID CreateFiberEx(SIZE_T, SIZE_T, DWORD, LPFIBER_START_ROUTINE, LPVOID);
        HANDLE CreateFileMappingA(HANDLE, LPSECURITY_ATTRIBUTES, DWORD, DWORD, DWORD, LPCSTR);
        HANDLE CreateFileMappingW(HANDLE, LPSECURITY_ATTRIBUTES, DWORD, DWORD, DWORD, LPCWSTR);
        BOOL CreateHardLinkA(LPCSTR, LPCSTR, LPSECURITY_ATTRIBUTES);
        BOOL CreateHardLinkW(LPCWSTR, LPCWSTR, LPSECURITY_ATTRIBUTES);
        HANDLE CreateJobObjectA(LPSECURITY_ATTRIBUTES, LPCSTR);
        HANDLE CreateJobObjectW(LPSECURITY_ATTRIBUTES, LPCWSTR);
        BOOL CreateProcessWithLogonW(LPCWSTR, LPCWSTR, LPCWSTR, DWORD, LPCWSTR, LPWSTR, DWORD, LPVOID, LPCWSTR, LPSTARTUPINFOW, LPPROCESS_INFORMATION);
        HANDLE CreateTimerQueue();
        BOOL CreateTimerQueueTimer(PHANDLE, HANDLE, WAITORTIMERCALLBACK, PVOID, DWORD, DWORD, ULONG);
        BOOL DeleteTimerQueue(HANDLE);
        BOOL DeleteTimerQueueEx(HANDLE, HANDLE);
        BOOL DeleteTimerQueueTimer(HANDLE, HANDLE, HANDLE);
        BOOL DeleteVolumeMountPointA(LPCSTR);
        BOOL DeleteVolumeMountPointW(LPCWSTR);
        BOOL DnsHostnameToComputerNameA(LPCSTR, LPSTR, LPDWORD);
        BOOL DnsHostnameToComputerNameW(LPCWSTR, LPWSTR, LPDWORD);
        BOOL EncryptFileA(LPCSTR);
        BOOL EncryptFileW(LPCWSTR);
        BOOL FileEncryptionStatusA(LPCSTR, LPDWORD);
        BOOL FileEncryptionStatusW(LPCWSTR, LPDWORD);
        HANDLE FindFirstVolumeA(LPCSTR, DWORD);
        HANDLE FindFirstVolumeMountPointA(LPSTR, LPSTR, DWORD);
        HANDLE FindFirstVolumeMountPointW(LPWSTR, LPWSTR, DWORD);
        HANDLE FindFirstVolumeW(LPCWSTR, DWORD);
        BOOL FindNextVolumeA(HANDLE, LPCSTR, DWORD);
        BOOL FindNextVolumeW(HANDLE, LPWSTR, DWORD);
        BOOL FindNextVolumeMountPointA(HANDLE, LPSTR, DWORD);
        BOOL FindNextVolumeMountPointW(HANDLE, LPWSTR, DWORD);
        BOOL FindVolumeClose(HANDLE);
        BOOL FindVolumeMountPointClose(HANDLE);
        BOOL FlushViewOfFile(PCVOID, SIZE_T);
        BOOL FreeUserPhysicalPages(HANDLE, PULONG_PTR, PULONG_PTR);
        BOOL GetComputerNameExA(COMPUTER_NAME_FORMAT, LPSTR, LPDWORD);
        BOOL GetComputerNameExW(COMPUTER_NAME_FORMAT, LPWSTR, LPDWORD);
        BOOL GetFileSizeEx(HANDLE, PLARGE_INTEGER);
        BOOL GetModuleHandleExA(DWORD, LPCSTR, HMODULE*);
        BOOL GetModuleHandleExW(DWORD, LPCWSTR, HMODULE*);
        HANDLE GetProcessHeap();
        DWORD GetProcessHeaps(DWORD, PHANDLE);
        BOOL GetProcessIoCounters(HANDLE, PIO_COUNTERS);
        BOOL GetSystemPowerStatus(LPSYSTEM_POWER_STATUS);
        UINT GetSystemWindowsDirectoryA(LPSTR, UINT);
        UINT GetSystemWindowsDirectoryW(LPWSTR, UINT);
        BOOL GetVolumeNameForVolumeMountPointA(LPCSTR, LPSTR, DWORD);
        BOOL GetVolumeNameForVolumeMountPointW(LPCWSTR, LPWSTR, DWORD);
        BOOL GetVolumePathNameA(LPCSTR, LPSTR, DWORD);
        BOOL GetVolumePathNameW(LPCWSTR, LPWSTR, DWORD);
        BOOL GlobalMemoryStatusEx(LPMEMORYSTATUSEX);
        BOOL IsBadCodePtr(FARPROC);
        BOOL IsSystemResumeAutomatic();
        BOOL MapUserPhysicalPages(PVOID, ULONG_PTR, PULONG_PTR);
        BOOL MapUserPhysicalPagesScatter(PVOID*, ULONG_PTR, PULONG_PTR);
        PVOID MapViewOfFile(HANDLE, DWORD, DWORD, DWORD, SIZE_T);
        PVOID MapViewOfFileEx(HANDLE, DWORD, DWORD, DWORD, SIZE_T, PVOID);
        HANDLE OpenFileMappingA(DWORD, BOOL, LPCSTR);
        HANDLE OpenFileMappingW(DWORD, BOOL, LPCWSTR);
        BOOL ProcessIdToSessionId(DWORD, DWORD*);
        BOOL QueryInformationJobObject(HANDLE, JOBOBJECTINFOCLASS, LPVOID, DWORD, LPDWORD);
        ULONG RemoveVectoredExceptionHandler(PVOID);
        BOOL ReplaceFileA(LPCSTR, LPCSTR, LPCSTR, DWORD, LPVOID, LPVOID);
        BOOL ReplaceFileW(LPCWSTR, LPCWSTR, LPCWSTR, DWORD, LPVOID, LPVOID);
        BOOL SetComputerNameExA(COMPUTER_NAME_FORMAT, LPCSTR);
        BOOL SetComputerNameExW(COMPUTER_NAME_FORMAT, LPCWSTR);
        BOOL SetFilePointerEx(HANDLE, LARGE_INTEGER, PLARGE_INTEGER, DWORD);
        BOOL SetInformationJobObject(HANDLE, JOBOBJECTINFOCLASS, LPVOID, DWORD);
        BOOL SetSecurityDescriptorControl(PSECURITY_DESCRIPTOR, SECURITY_DESCRIPTOR_CONTROL, SECURITY_DESCRIPTOR_CONTROL);
        BOOL SetSystemPowerState(BOOL, BOOL);
        EXECUTION_STATE SetThreadExecutionState(EXECUTION_STATE);
        DWORD SetThreadIdealProcessor(HANDLE, DWORD);
        BOOL SetVolumeMountPointA(LPCSTR, LPCSTR);
        BOOL SetVolumeMountPointW(LPCWSTR, LPCWSTR);
        BOOL TerminateJobObject(HANDLE, UINT);
        BOOL UnmapViewOfFile(PCVOID);
        BOOL UnregisterWait(HANDLE);
        BOOL UnregisterWaitEx(HANDLE, HANDLE);
        BOOL VerifyVersionInfoA(LPOSVERSIONINFOEXA, DWORD, DWORDLONG);
        BOOL VerifyVersionInfoW(LPOSVERSIONINFOEXW, DWORD, DWORDLONG);
    }

    static if (_WIN32_WINNT >= 0x501) {
        BOOL ActivateActCtx(HANDLE, ULONG_PTR*);
        void AddRefActCtx(HANDLE);
        BOOL CheckNameLegalDOS8Dot3A(LPCSTR, LPSTR, DWORD, PBOOL, PBOOL);
        BOOL CheckNameLegalDOS8Dot3W(LPCWSTR, LPSTR, DWORD, PBOOL, PBOOL);
        BOOL CheckRemoteDebuggerPresent(HANDLE, PBOOL);
        BOOL ConvertFiberToThread();
        HANDLE CreateActCtxA(PCACTCTXA);
        HANDLE CreateActCtxW(PCACTCTXW);
        HANDLE CreateMemoryResourceNotification(MEMORY_RESOURCE_NOTIFICATION_TYPE);
        BOOL DeactivateActCtx(DWORD, ULONG_PTR);
        BOOL DebugActiveProcessStop(DWORD);
        BOOL DebugBreakProcess(HANDLE);
        BOOL DebugSetProcessKillOnExit(BOOL);
        BOOL FindActCtxSectionGuid(DWORD, const(GUID)*, ULONG, const(GUID)*,
          PACTCTX_SECTION_KEYED_DATA);
        BOOL FindActCtxSectionStringA(DWORD, const(GUID)*, ULONG, LPCSTR,
          PACTCTX_SECTION_KEYED_DATA);
        BOOL FindActCtxSectionStringW(DWORD, const(GUID)*, ULONG, LPCWSTR,
          PACTCTX_SECTION_KEYED_DATA);
        BOOL GetCurrentActCtx(HANDLE*);
        VOID GetNativeSystemInfo(LPSYSTEM_INFO);
        BOOL GetProcessHandleCount(HANDLE, PDWORD);
        BOOL GetSystemRegistryQuota(PDWORD, PDWORD);
        BOOL GetSystemTimes(LPFILETIME, LPFILETIME, LPFILETIME);
        UINT GetSystemWow64DirectoryA(LPSTR, UINT);
        UINT GetSystemWow64DirectoryW(LPWSTR, UINT);
        BOOL GetThreadIOPendingFlag(HANDLE, PBOOL);
        BOOL GetVolumePathNamesForVolumeNameA(LPCSTR, LPSTR, DWORD, PDWORD);
        BOOL GetVolumePathNamesForVolumeNameW(LPCWSTR, LPWSTR, DWORD, PDWORD);
        UINT GetWriteWatch(DWORD, PVOID, SIZE_T, PVOID*, PULONG_PTR, PULONG);
        BOOL HeapQueryInformation(HANDLE, HEAP_INFORMATION_CLASS, PVOID, SIZE_T, PSIZE_T);
        BOOL HeapSetInformation(HANDLE, HEAP_INFORMATION_CLASS, PVOID, SIZE_T);
        BOOL IsProcessInJob(HANDLE, HANDLE, PBOOL);
        BOOL IsWow64Process(HANDLE, PBOOL);
        BOOL QueryActCtxW(DWORD, HANDLE, PVOID, ULONG, PVOID, SIZE_T, SIZE_T*);
        BOOL QueryMemoryResourceNotification(HANDLE, PBOOL);
        void ReleaseActCtx(HANDLE);
        UINT ResetWriteWatch(LPVOID, SIZE_T);
        BOOL SetFileShortNameA(HANDLE, LPCSTR);
        BOOL SetFileShortNameW(HANDLE, LPCWSTR);
        BOOL SetFileValidData(HANDLE, LONGLONG);
        BOOL ZombifyActCtx(HANDLE);
    }

    static if (_WIN32_WINNT >= 0x502) {
        DWORD GetFirmwareEnvironmentVariableA(LPCSTR, LPCSTR, PVOID, DWORD);
        DWORD GetFirmwareEnvironmentVariableW(LPCWSTR, LPCWSTR, PVOID, DWORD);
        DWORD GetDllDirectoryA(DWORD, LPSTR);
        DWORD GetDllDirectoryW(DWORD, LPWSTR);
        DWORD GetThreadId(HANDLE);
        DWORD GetProcessId(HANDLE);
        HANDLE ReOpenFile(HANDLE, DWORD, DWORD, DWORD);
        BOOL SetDllDirectoryA(LPCSTR);
        BOOL SetDllDirectoryW(LPCWSTR);
        BOOL SetFirmwareEnvironmentVariableA(LPCSTR, LPCSTR, PVOID, DWORD);
        BOOL SetFirmwareEnvironmentVariableW(LPCWSTR, LPCWSTR, PVOID, DWORD);
    }

    // ???
    static if (_WIN32_WINNT >= 0x510) {
        VOID RestoreLastError(DWORD);
    }

    static if (_WIN32_WINNT >= 0x600) {
        BOOL CreateSymbolicLinkA(LPCSTR, LPCSTR, DWORD);
        BOOL CreateSymbolicLinkW(LPCWSTR, LPCWSTR, DWORD);
        BOOL GetFileInformationByHandleEx(HANDLE, FILE_INFO_BY_HANDLE_CLASS, LPVOID, DWORD);
    }
}

// For compatibility with old core.sys.windows.windows:
version (LittleEndian) nothrow @nogc
{
    BOOL QueryPerformanceCounter()(long* lpPerformanceCount) { return QueryPerformanceCounter(cast(PLARGE_INTEGER)lpPerformanceCount); }
    BOOL QueryPerformanceFrequency()(long* lpFrequency) { return QueryPerformanceFrequency(cast(PLARGE_INTEGER)lpFrequency); }
}

mixin DECLARE_AW!("STARTUPINFO");
version (Unicode) {
    //alias STARTUPINFOW STARTUPINFO;
    alias WIN32_FIND_DATA = WIN32_FIND_DATAW;
    alias ENUMRESLANGPROC = ENUMRESLANGPROCW;
    alias ENUMRESNAMEPROC = ENUMRESNAMEPROCW;
    alias ENUMRESTYPEPROC = ENUMRESTYPEPROCW;
    alias AddAtom = AddAtomW;
    alias BeginUpdateResource = BeginUpdateResourceW;
    alias BuildCommDCB = BuildCommDCBW;
    alias BuildCommDCBAndTimeouts = BuildCommDCBAndTimeoutsW;
    alias CallNamedPipe = CallNamedPipeW;
    alias CommConfigDialog = CommConfigDialogW;
    alias CopyFile = CopyFileW;
    alias CopyFileEx = CopyFileExW;
    alias CreateDirectory = CreateDirectoryW;
    alias CreateDirectoryEx = CreateDirectoryExW;
    alias CreateEvent = CreateEventW;
    alias CreateFile = CreateFileW;
    alias CreateMailslot = CreateMailslotW;
    alias CreateMutex = CreateMutexW;
    alias CreateProcess = CreateProcessW;
    alias CreateSemaphore = CreateSemaphoreW;
    alias DeleteFile = DeleteFileW;
    alias EndUpdateResource = EndUpdateResourceW;
    alias EnumResourceLanguages = EnumResourceLanguagesW;
    alias EnumResourceNames = EnumResourceNamesW;
    alias EnumResourceTypes = EnumResourceTypesW;
    alias ExpandEnvironmentStrings = ExpandEnvironmentStringsW;
    alias FatalAppExit = FatalAppExitW;
    alias FindAtom = FindAtomW;
    alias FindFirstChangeNotification = FindFirstChangeNotificationW;
    alias FindFirstFile = FindFirstFileW;
    alias FindNextFile = FindNextFileW;
    alias FindResource = FindResourceW;
    alias FindResourceEx = FindResourceExW;
    alias FormatMessage = FormatMessageW;
    alias FreeEnvironmentStrings = FreeEnvironmentStringsW;
    alias GetAtomName = GetAtomNameW;
    alias GetCommandLine = GetCommandLineW;
    alias GetComputerName = GetComputerNameW;
    alias GetCurrentDirectory = GetCurrentDirectoryW;
    alias GetDefaultCommConfig = GetDefaultCommConfigW;
    alias GetDiskFreeSpace = GetDiskFreeSpaceW;
    alias GetDiskFreeSpaceEx = GetDiskFreeSpaceExW;
    alias GetDriveType = GetDriveTypeW;
    alias GetEnvironmentStrings = GetEnvironmentStringsW;
    alias GetEnvironmentVariable = GetEnvironmentVariableW;
    alias GetFileAttributes = GetFileAttributesW;
    alias GetFullPathName = GetFullPathNameW;
    alias GetLogicalDriveStrings = GetLogicalDriveStringsW;
    alias GetModuleFileName = GetModuleFileNameW;
    alias GetModuleHandle = GetModuleHandleW;
    alias GetNamedPipeHandleState = GetNamedPipeHandleStateW;
    alias GetPrivateProfileInt = GetPrivateProfileIntW;
    alias GetPrivateProfileSection = GetPrivateProfileSectionW;
    alias GetPrivateProfileSectionNames = GetPrivateProfileSectionNamesW;
    alias GetPrivateProfileString = GetPrivateProfileStringW;
    alias GetPrivateProfileStruct = GetPrivateProfileStructW;
    alias GetProfileInt = GetProfileIntW;
    alias GetProfileSection = GetProfileSectionW;
    alias GetProfileString = GetProfileStringW;
    alias GetShortPathName = GetShortPathNameW;
    alias GetStartupInfo = GetStartupInfoW;
    alias GetSystemDirectory = GetSystemDirectoryW;
    alias GetTempFileName = GetTempFileNameW;
    alias GetTempPath = GetTempPathW;
    alias GetUserName = GetUserNameW;
    alias GetVersionEx = GetVersionExW;
    alias GetVolumeInformation = GetVolumeInformationW;
    alias GetWindowsDirectory = GetWindowsDirectoryW;
    alias GlobalAddAtom = GlobalAddAtomW;
    alias GlobalFindAtom = GlobalFindAtomW;
    alias GlobalGetAtomName = GlobalGetAtomNameW;
    alias IsBadStringPtr = IsBadStringPtrW;
    alias LoadLibrary = LoadLibraryW;
    alias LoadLibraryEx = LoadLibraryExW;
    alias lstrcat = lstrcatW;
    alias lstrcmp = lstrcmpW;
    alias lstrcmpi = lstrcmpiW;
    alias lstrcpy = lstrcpyW;
    alias lstrcpyn = lstrcpynW;
    alias lstrlen = lstrlenW;
    alias MoveFile = MoveFileW;
    alias OpenEvent = OpenEventW;
    alias OpenMutex = OpenMutexW;
    alias OpenSemaphore = OpenSemaphoreW;
    alias OutputDebugString = OutputDebugStringW;
    alias RemoveDirectory = RemoveDirectoryW;
    alias SearchPath = SearchPathW;
    alias SetComputerName = SetComputerNameW;
    alias SetCurrentDirectory = SetCurrentDirectoryW;
    alias SetDefaultCommConfig = SetDefaultCommConfigW;
    alias SetEnvironmentVariable = SetEnvironmentVariableW;
    alias SetFileAttributes = SetFileAttributesW;
    alias SetVolumeLabel = SetVolumeLabelW;
    alias WaitNamedPipe = WaitNamedPipeW;
    alias WritePrivateProfileSection = WritePrivateProfileSectionW;
    alias WritePrivateProfileString = WritePrivateProfileStringW;
    alias WritePrivateProfileStruct = WritePrivateProfileStructW;
    alias WriteProfileSection = WriteProfileSectionW;
    alias WriteProfileString = WriteProfileStringW;
    alias CreateWaitableTimer = CreateWaitableTimerW;
    alias GetFileAttributesEx = GetFileAttributesExW;
    alias GetLongPathName = GetLongPathNameW;
    alias QueryDosDevice = QueryDosDeviceW;

    alias HW_PROFILE_INFO = HW_PROFILE_INFOW;
    alias AccessCheckAndAuditAlarm = AccessCheckAndAuditAlarmW;
    alias BackupEventLog = BackupEventLogW;
    alias ClearEventLog = ClearEventLogW;
    alias CreateNamedPipe = CreateNamedPipeW;
    alias CreateProcessAsUser = CreateProcessAsUserW;
    alias DefineDosDevice = DefineDosDeviceW;
    alias FindFirstFileEx = FindFirstFileExW;
    alias GetBinaryType = GetBinaryTypeW;
    alias GetCompressedFileSize = GetCompressedFileSizeW;
    alias GetFileSecurity = GetFileSecurityW;
    alias LogonUser = LogonUserW;
    alias LookupAccountName = LookupAccountNameW;
    alias LookupAccountSid = LookupAccountSidW;
    alias LookupPrivilegeDisplayName = LookupPrivilegeDisplayNameW;
    alias LookupPrivilegeName = LookupPrivilegeNameW;
    alias LookupPrivilegeValue = LookupPrivilegeValueW;
    alias MoveFileEx = MoveFileExW;
    alias ObjectCloseAuditAlarm = ObjectCloseAuditAlarmW;
    alias ObjectDeleteAuditAlarm = ObjectDeleteAuditAlarmW;
    alias ObjectOpenAuditAlarm = ObjectOpenAuditAlarmW;
    alias ObjectPrivilegeAuditAlarm = ObjectPrivilegeAuditAlarmW;
    alias OpenBackupEventLog = OpenBackupEventLogW;
    alias OpenEventLog = OpenEventLogW;
    alias PrivilegedServiceAuditAlarm = PrivilegedServiceAuditAlarmW;
    alias ReadEventLog = ReadEventLogW;
    alias RegisterEventSource = RegisterEventSourceW;
    alias ReportEvent = ReportEventW;
    alias SetFileSecurity = SetFileSecurityW;
    alias UpdateResource = UpdateResourceW;

    static if (_WIN32_WINNT >= 0x500) {
        alias CreateFileMapping = CreateFileMappingW;
        alias CreateHardLink = CreateHardLinkW;
        alias CreateJobObject = CreateJobObjectW;
        alias DeleteVolumeMountPoint = DeleteVolumeMountPointW;
        alias DnsHostnameToComputerName = DnsHostnameToComputerNameW;
        alias EncryptFile = EncryptFileW;
        alias FileEncryptionStatus = FileEncryptionStatusW;
        alias FindFirstVolume = FindFirstVolumeW;
        alias FindFirstVolumeMountPoint = FindFirstVolumeMountPointW;
        alias FindNextVolume = FindNextVolumeW;
        alias FindNextVolumeMountPoint = FindNextVolumeMountPointW;
        alias GetModuleHandleEx = GetModuleHandleExW;
        alias GetSystemWindowsDirectory = GetSystemWindowsDirectoryW;
        alias GetVolumeNameForVolumeMountPoint = GetVolumeNameForVolumeMountPointW;
        alias GetVolumePathName = GetVolumePathNameW;
        alias OpenFileMapping = OpenFileMappingW;
        alias ReplaceFile = ReplaceFileW;
        alias SetVolumeMountPoint = SetVolumeMountPointW;
        alias VerifyVersionInfo = VerifyVersionInfoW;
    }

    static if (_WIN32_WINNT >= 0x501) {
        alias ACTCTX = ACTCTXW;
        alias CheckNameLegalDOS8Dot3 = CheckNameLegalDOS8Dot3W;
        alias CreateActCtx = CreateActCtxW;
        alias FindActCtxSectionString = FindActCtxSectionStringW;
        alias GetSystemWow64Directory = GetSystemWow64DirectoryW;
        alias GetVolumePathNamesForVolumeName = GetVolumePathNamesForVolumeNameW;
        alias SetFileShortName = SetFileShortNameW;
    }

    static if (_WIN32_WINNT >= 0x502) {
        alias SetFirmwareEnvironmentVariable = SetFirmwareEnvironmentVariableW;
        alias SetDllDirectory = SetDllDirectoryW;
        alias GetDllDirectory = GetDllDirectoryW;
    }

    static if (_WIN32_WINNT >= 0x600) {
        alias CreateSymbolicLink = CreateSymbolicLinkW;
    }

} else {
    //alias STARTUPINFOA STARTUPINFO;
    alias WIN32_FIND_DATA = WIN32_FIND_DATAA;
    alias ENUMRESLANGPROC = ENUMRESLANGPROCW;
    alias ENUMRESNAMEPROC = ENUMRESNAMEPROCW;
    alias ENUMRESTYPEPROC = ENUMRESTYPEPROCW;
    alias AddAtom = AddAtomA;
    alias BeginUpdateResource = BeginUpdateResourceA;
    alias BuildCommDCB = BuildCommDCBA;
    alias BuildCommDCBAndTimeouts = BuildCommDCBAndTimeoutsA;
    alias CallNamedPipe = CallNamedPipeA;
    alias CommConfigDialog = CommConfigDialogA;
    alias CopyFile = CopyFileA;
    alias CopyFileEx = CopyFileExA;
    alias CreateDirectory = CreateDirectoryA;
    alias CreateDirectoryEx = CreateDirectoryExA;
    alias CreateEvent = CreateEventA;
    alias CreateFile = CreateFileA;
    alias CreateMailslot = CreateMailslotA;
    alias CreateMutex = CreateMutexA;
    alias CreateProcess = CreateProcessA;
    alias CreateSemaphore = CreateSemaphoreA;
    alias DeleteFile = DeleteFileA;
    alias EndUpdateResource = EndUpdateResourceA;
    alias EnumResourceLanguages = EnumResourceLanguagesA;
    alias EnumResourceNames = EnumResourceNamesA;
    alias EnumResourceTypes = EnumResourceTypesA;
    alias ExpandEnvironmentStrings = ExpandEnvironmentStringsA;
    alias FatalAppExit = FatalAppExitA;
    alias FindAtom = FindAtomA;
    alias FindFirstChangeNotification = FindFirstChangeNotificationA;
    alias FindFirstFile = FindFirstFileA;
    alias FindNextFile = FindNextFileA;
    alias FindResource = FindResourceA;
    alias FindResourceEx = FindResourceExA;
    alias FormatMessage = FormatMessageA;
    alias FreeEnvironmentStrings = FreeEnvironmentStringsA;
    alias GetAtomName = GetAtomNameA;
    alias GetCommandLine = GetCommandLineA;
    alias GetComputerName = GetComputerNameA;
    alias GetCurrentDirectory = GetCurrentDirectoryA;
    alias GetDefaultCommConfig = GetDefaultCommConfigA;
    alias GetDiskFreeSpace = GetDiskFreeSpaceA;
    alias GetDiskFreeSpaceEx = GetDiskFreeSpaceExA;
    alias GetDriveType = GetDriveTypeA;
    alias GetEnvironmentStrings = GetEnvironmentStringsA;
    alias GetEnvironmentVariable = GetEnvironmentVariableA;
    alias GetFileAttributes = GetFileAttributesA;
    alias GetFullPathName = GetFullPathNameA;
    alias GetLogicalDriveStrings = GetLogicalDriveStringsA;
    alias GetNamedPipeHandleState = GetNamedPipeHandleStateA;
    alias GetModuleHandle = GetModuleHandleA;
    alias GetModuleFileName = GetModuleFileNameA;
    alias GetPrivateProfileInt = GetPrivateProfileIntA;
    alias GetPrivateProfileSection = GetPrivateProfileSectionA;
    alias GetPrivateProfileSectionNames = GetPrivateProfileSectionNamesA;
    alias GetPrivateProfileString = GetPrivateProfileStringA;
    alias GetPrivateProfileStruct = GetPrivateProfileStructA;
    alias GetProfileInt = GetProfileIntA;
    alias GetProfileSection = GetProfileSectionA;
    alias GetProfileString = GetProfileStringA;
    alias GetShortPathName = GetShortPathNameA;
    alias GetStartupInfo = GetStartupInfoA;
    alias GetSystemDirectory = GetSystemDirectoryA;
    alias GetTempFileName = GetTempFileNameA;
    alias GetTempPath = GetTempPathA;
    alias GetUserName = GetUserNameA;
    alias GetVersionEx = GetVersionExA;
    alias GetVolumeInformation = GetVolumeInformationA;
    alias GetWindowsDirectory = GetWindowsDirectoryA;
    alias GlobalAddAtom = GlobalAddAtomA;
    alias GlobalFindAtom = GlobalFindAtomA;
    alias GlobalGetAtomName = GlobalGetAtomNameA;
    alias IsBadStringPtr = IsBadStringPtrA;
    alias LoadLibrary = LoadLibraryA;
    alias LoadLibraryEx = LoadLibraryExA;
    alias lstrcat = lstrcatA;
    alias lstrcmp = lstrcmpA;
    alias lstrcmpi = lstrcmpiA;
    alias lstrcpy = lstrcpyA;
    alias lstrcpyn = lstrcpynA;
    alias lstrlen = lstrlenA;
    alias MoveFile = MoveFileA;
    alias OpenEvent = OpenEventA;
    alias OpenMutex = OpenMutexA;
    alias OpenSemaphore = OpenSemaphoreA;
    alias OutputDebugString = OutputDebugStringA;
    alias RemoveDirectory = RemoveDirectoryA;
    alias SearchPath = SearchPathA;
    alias SetComputerName = SetComputerNameA;
    alias SetCurrentDirectory = SetCurrentDirectoryA;
    alias SetDefaultCommConfig = SetDefaultCommConfigA;
    alias SetEnvironmentVariable = SetEnvironmentVariableA;
    alias SetFileAttributes = SetFileAttributesA;
    alias SetVolumeLabel = SetVolumeLabelA;
    alias WaitNamedPipe = WaitNamedPipeA;
    alias WritePrivateProfileSection = WritePrivateProfileSectionA;
    alias WritePrivateProfileString = WritePrivateProfileStringA;
    alias WritePrivateProfileStruct = WritePrivateProfileStructA;
    alias WriteProfileSection = WriteProfileSectionA;
    alias WriteProfileString = WriteProfileStringA;
    alias CreateWaitableTimer = CreateWaitableTimerA;
    alias GetFileAttributesEx = GetFileAttributesExA;
    alias GetLongPathName = GetLongPathNameA;
    alias QueryDosDevice = QueryDosDeviceA;

    alias HW_PROFILE_INFO = HW_PROFILE_INFOA;
    alias AccessCheckAndAuditAlarm = AccessCheckAndAuditAlarmA;
    alias BackupEventLog = BackupEventLogA;
    alias ClearEventLog = ClearEventLogA;
    alias CreateNamedPipe = CreateNamedPipeA;
    alias CreateProcessAsUser = CreateProcessAsUserA;
    alias DefineDosDevice = DefineDosDeviceA;
    alias FindFirstFileEx = FindFirstFileExA;
    alias GetBinaryType = GetBinaryTypeA;
    alias GetCompressedFileSize = GetCompressedFileSizeA;
    alias GetFileSecurity = GetFileSecurityA;
    alias LogonUser = LogonUserA;
    alias LookupAccountName = LookupAccountNameA;
    alias LookupAccountSid = LookupAccountSidA;
    alias LookupPrivilegeDisplayName = LookupPrivilegeDisplayNameA;
    alias LookupPrivilegeName = LookupPrivilegeNameA;
    alias LookupPrivilegeValue = LookupPrivilegeValueA;
    alias MoveFileEx = MoveFileExA;
    alias ObjectCloseAuditAlarm = ObjectCloseAuditAlarmA;
    alias ObjectDeleteAuditAlarm = ObjectDeleteAuditAlarmA;
    alias ObjectOpenAuditAlarm = ObjectOpenAuditAlarmA;
    alias ObjectPrivilegeAuditAlarm = ObjectPrivilegeAuditAlarmA;
    alias OpenBackupEventLog = OpenBackupEventLogA;
    alias OpenEventLog = OpenEventLogA;
    alias PrivilegedServiceAuditAlarm = PrivilegedServiceAuditAlarmA;
    alias ReadEventLog = ReadEventLogA;
    alias RegisterEventSource = RegisterEventSourceA;
    alias ReportEvent = ReportEventA;
    alias SetFileSecurity = SetFileSecurityA;
    alias UpdateResource = UpdateResourceA;

    static if (_WIN32_WINNT >= 0x500) {
        alias CreateFileMapping = CreateFileMappingA;
        alias CreateHardLink = CreateHardLinkA;
        alias CreateJobObject = CreateJobObjectA;
        alias DeleteVolumeMountPoint = DeleteVolumeMountPointA;
        alias DnsHostnameToComputerName = DnsHostnameToComputerNameA;
        alias EncryptFile = EncryptFileA;
        alias FileEncryptionStatus = FileEncryptionStatusA;
        alias FindFirstVolume = FindFirstVolumeA;
        alias FindFirstVolumeMountPoint = FindFirstVolumeMountPointA;
        alias FindNextVolume = FindNextVolumeA;
        alias FindNextVolumeMountPoint = FindNextVolumeMountPointA;
        alias GetModuleHandleEx = GetModuleHandleExA;
        alias GetSystemWindowsDirectory = GetSystemWindowsDirectoryA;
        alias GetVolumeNameForVolumeMountPoint = GetVolumeNameForVolumeMountPointA;
        alias GetVolumePathName = GetVolumePathNameA;
        alias OpenFileMapping = OpenFileMappingA;
        alias ReplaceFile = ReplaceFileA;
        alias SetVolumeMountPoint = SetVolumeMountPointA;
        alias VerifyVersionInfo = VerifyVersionInfoA;
    }

    static if (_WIN32_WINNT >= 0x501) {
        alias ACTCTX = ACTCTXA;
        alias CheckNameLegalDOS8Dot3 = CheckNameLegalDOS8Dot3A;
        alias CreateActCtx = CreateActCtxA;
        alias FindActCtxSectionString = FindActCtxSectionStringA;
        alias GetSystemWow64Directory = GetSystemWow64DirectoryA;
        alias GetVolumePathNamesForVolumeName = GetVolumePathNamesForVolumeNameA;
        alias SetFileShortName = SetFileShortNameA;
    }

    static if (_WIN32_WINNT >= 0x502) {
        alias GetDllDirectory = GetDllDirectoryA;
        alias SetDllDirectory = SetDllDirectoryA;
        alias SetFirmwareEnvironmentVariable = SetFirmwareEnvironmentVariableA;
    }

    static if (_WIN32_WINNT >= 0x600) {
        alias CreateSymbolicLink = CreateSymbolicLinkA;
    }
}

alias LPSTARTUPINFO = STARTUPINFO*;
alias LPWIN32_FIND_DATA = WIN32_FIND_DATA*;

alias LPHW_PROFILE_INFO = HW_PROFILE_INFO*;

static if (_WIN32_WINNT >= 0x501) {
    alias PACTCTX = ACTCTX*, PCACTCTX = ACTCTX*;
}
