#![cfg(windows)]
extern crate winapi;
use winapi::*;
extern "system" {
pub fn AcquireSRWLockExclusive(SRWLock: PSRWLOCK);
pub fn AcquireSRWLockShared(SRWLock: PSRWLOCK);
pub fn ActivateActCtx(hActCtx: HANDLE, lpCookie: *mut ULONG_PTR) -> BOOL;
pub fn AddAtomA(lpString: LPCSTR) -> ATOM;
pub fn AddAtomW(lpString: LPCWSTR) -> ATOM;
pub fn AddConsoleAliasA(Source: LPSTR, Target: LPSTR, ExeName: LPSTR) -> BOOL;
pub fn AddConsoleAliasW(Source: LPWSTR, Target: LPWSTR, ExeName: LPWSTR) -> BOOL;
pub fn AddDllDirectory(NewDirectory: PCWSTR) -> DLL_DIRECTORY_COOKIE;
pub fn AddIntegrityLabelToBoundaryDescriptor(
BoundaryDescriptor: *mut HANDLE, IntegrityLabel: PSID,
) -> BOOL;
pub fn AddRefActCtx(hActCtx: HANDLE);
pub fn AddResourceAttributeAce(
pAcl: PACL, dwAceRevision: DWORD, AceFlags: DWORD, AccessMask: DWORD, pSid: PSID,
pAttributeInfo: PCLAIM_SECURITY_ATTRIBUTES_INFORMATION, pReturnLength: PDWORD,
) -> BOOL;
pub fn AddSIDToBoundaryDescriptor(BoundaryDescriptor: *mut HANDLE, RequiredSid: PSID) -> BOOL;
pub fn AddScopedPolicyIDAce(
pAcl: PACL, dwAceRevision: DWORD, AceFlags: DWORD, AccessMask: DWORD, pSid: PSID,
) -> BOOL;
pub fn AddSecureMemoryCacheCallback(pfnCallBack: PSECURE_MEMORY_CACHE_CALLBACK) -> BOOL;
pub fn AddVectoredContinueHandler(First: ULONG, Handler: PVECTORED_EXCEPTION_HANDLER) -> PVOID;
pub fn AddVectoredExceptionHandler(
First: ULONG, Handler: PVECTORED_EXCEPTION_HANDLER,
) -> PVOID;
pub fn AllocConsole() -> BOOL;
pub fn AllocateUserPhysicalPages(
hProcess: HANDLE, NumberOfPages: PULONG_PTR, PageArray: PULONG_PTR,
) -> BOOL;
pub fn AllocateUserPhysicalPagesNuma(
hProcess: HANDLE, NumberOfPages: PULONG_PTR, PageArray: PULONG_PTR, nndPreferred: DWORD,
) -> BOOL;
pub fn ApplicationRecoveryFinished(bSuccess: BOOL);
pub fn ApplicationRecoveryInProgress(pbCancelled: PBOOL) -> HRESULT;
pub fn AreFileApisANSI() -> BOOL;
pub fn AssignProcessToJobObject(hJob: HANDLE, hProcess: HANDLE) -> BOOL;
pub fn AttachConsole(dwProcessId: DWORD) -> BOOL;
pub fn BackupRead(
hFile: HANDLE, lpBuffer: LPBYTE, nNumberOfBytesToRead: DWORD, lpNumberOfBytesRead: LPDWORD,
bAbort: BOOL, bProcessSecurity: BOOL, lpContext: *mut LPVOID,
) -> BOOL;
pub fn BackupSeek(
hFile: HANDLE, dwLowBytesToSeek: DWORD, dwHighBytesToSeek: DWORD,
lpdwLowByteSeeked: LPDWORD, lpdwHighByteSeeked: LPDWORD, lpContext: *mut LPVOID,
) -> BOOL;
pub fn BackupWrite(
hFile: HANDLE, lpBuffer: LPBYTE, nNumberOfBytesToWrite: DWORD,
lpNumberOfBytesWritten: LPDWORD, bAbort: BOOL, bProcessSecurity: BOOL,
lpContext: *mut LPVOID,
) -> BOOL;
pub fn Beep(dwFreq: DWORD, dwDuration: DWORD) -> BOOL;
pub fn BeginUpdateResourceA(pFileName: LPCSTR, bDeleteExistingResources: BOOL) -> HANDLE;
pub fn BeginUpdateResourceW(pFileName: LPCWSTR, bDeleteExistingResources: BOOL) -> HANDLE;
pub fn BindIoCompletionCallback(
FileHandle: HANDLE, Function: LPOVERLAPPED_COMPLETION_ROUTINE, Flags: ULONG,
) -> BOOL;
pub fn BuildCommDCBA(lpDef: LPCSTR, lpDCB: LPDCB) -> BOOL;
pub fn BuildCommDCBAndTimeoutsA(
lpDef: LPCSTR, lpDCB: LPDCB, lpCommTimeouts: LPCOMMTIMEOUTS,
) -> BOOL;
pub fn BuildCommDCBAndTimeoutsW(
lpDef: LPCWSTR, lpDCB: LPDCB, lpCommTimeouts: LPCOMMTIMEOUTS,
) -> BOOL;
pub fn BuildCommDCBW(lpDef: LPCWSTR, lpDCB: LPDCB) -> BOOL;
pub fn CallNamedPipeA(
lpNamedPipeName: LPCSTR, lpInBuffer: LPVOID, nInBufferSize: DWORD, lpOutBuffer: LPVOID,
nOutBufferSize: DWORD, lpBytesRead: LPDWORD, nTimeOut: DWORD,
) -> BOOL;
pub fn CallNamedPipeW(
lpNamedPipeName: LPCWSTR, lpInBuffer: LPVOID, nInBufferSize: DWORD, lpOutBuffer: LPVOID,
nOutBufferSize: DWORD, lpBytesRead: LPDWORD, nTimeOut: DWORD,
) -> BOOL;
pub fn CallbackMayRunLong(pci: PTP_CALLBACK_INSTANCE) -> BOOL;
pub fn CalloutOnFiberStack(
lpFiber: PVOID, lpStartAddress: PFIBER_CALLOUT_ROUTINE, lpParameter: PVOID,
) -> PVOID;
pub fn CancelDeviceWakeupRequest(hDevice: HANDLE) -> BOOL;
pub fn CancelIo(hFile: HANDLE) -> BOOL;
pub fn CancelIoEx(hFile: HANDLE, lpOverlapped: LPOVERLAPPED) -> BOOL;
pub fn CancelSynchronousIo(hThread: HANDLE) -> BOOL;
pub fn CancelThreadpoolIo(pio: PTP_IO);
pub fn CancelTimerQueueTimer(TimerQueue: HANDLE, Timer: HANDLE) -> BOOL;
pub fn CancelWaitableTimer(hTimer: HANDLE) -> BOOL;
pub fn CeipIsOptedIn() -> BOOL;
pub fn ChangeTimerQueueTimer(
TimerQueue: HANDLE, Timer: HANDLE, DueTime: ULONG, Period: ULONG,
) -> BOOL;
pub fn CheckNameLegalDOS8Dot3A(
lpName: LPCSTR, lpOemName: LPSTR, OemNameSize: DWORD, pbNameContainsSpaces: PBOOL,
pbNameLegal: PBOOL,
) -> BOOL;
pub fn CheckNameLegalDOS8Dot3W(
lpName: LPCWSTR, lpOemName: LPSTR, OemNameSize: DWORD, pbNameContainsSpaces: PBOOL,
pbNameLegal: PBOOL,
) -> BOOL;
pub fn CheckRemoteDebuggerPresent(hProcess: HANDLE, pbDebuggerPresent: PBOOL) -> BOOL;
pub fn CheckTokenCapability(
TokenHandle: HANDLE, CapabilitySidToCheck: PSID, HasCapability: PBOOL,
) -> BOOL;
pub fn CheckTokenMembershipEx(
TokenHandle: HANDLE, SidToCheck: PSID, Flags: DWORD, IsMember: PBOOL,
) -> BOOL;
pub fn ClearCommBreak(hFile: HANDLE) -> BOOL;
pub fn ClearCommError(hFile: HANDLE, lpErrors: LPDWORD, lpStat: LPCOMSTAT) -> BOOL;
pub fn CloseHandle(hObject: HANDLE) -> BOOL;
pub fn ClosePrivateNamespace(Handle: HANDLE, Flags: ULONG) -> BOOLEAN;
pub fn CloseThreadpool(ptpp: PTP_POOL);
pub fn CloseThreadpoolCleanupGroup(ptpcg: PTP_CLEANUP_GROUP);
pub fn CloseThreadpoolCleanupGroupMembers(
ptpcg: PTP_CLEANUP_GROUP, fCancelPendingCallbacks: BOOL, pvCleanupContext: PVOID,
);
pub fn CloseThreadpoolIo(pio: PTP_IO);
pub fn CloseThreadpoolTimer(pti: PTP_TIMER);
pub fn CloseThreadpoolWait(pwa: PTP_WAIT);
pub fn CloseThreadpoolWork(pwk: PTP_WORK);
pub fn CommConfigDialogA(lpszName: LPCSTR, hWnd: HWND, lpCC: LPCOMMCONFIG) -> BOOL;
pub fn CommConfigDialogW(lpszName: LPCWSTR, hWnd: HWND, lpCC: LPCOMMCONFIG) -> BOOL;
pub fn CompareFileTime(lpFileTime1: *const FILETIME, lpFileTime2: *const FILETIME) -> LONG;
pub fn CompareStringA(
Locale: LCID, dwCmpFlags: DWORD, lpString1: PCNZCH, cchCount1: c_int, lpString2: PCNZCH,
cchCount2: c_int,
) -> c_int;
pub fn CompareStringEx(
lpLocaleName: LPCWSTR, dwCmpFlags: DWORD, lpString1: LPCWCH, cchCount1: c_int,
lpString2: LPCWCH, cchCount2: c_int, lpVersionInformation: LPNLSVERSIONINFO,
lpReserved: LPVOID, lParam: LPARAM,
) -> c_int;
pub fn CompareStringOrdinal(
lpString1: LPCWCH, cchCount1: c_int, lpString2: LPCWCH, cchCount2: c_int, bIgnoreCase: BOOL,
) -> c_int;
pub fn CompareStringW(
Locale: LCID, dwCmpFlags: DWORD, lpString1: PCNZWCH, cchCount1: c_int, lpString2: PCNZWCH,
cchCount2: c_int,
) -> c_int;
pub fn ConnectNamedPipe(hNamedPipe: HANDLE, lpOverlapped: LPOVERLAPPED) -> BOOL;
pub fn ContinueDebugEvent(
dwProcessId: DWORD, dwThreadId: DWORD, dwContinueStatus: DWORD,
) -> BOOL;
pub fn ConvertDefaultLocale(Locale: LCID) -> LCID;
pub fn ConvertFiberToThread() -> BOOL;
pub fn ConvertThreadToFiber(lpParameter: LPVOID) -> LPVOID;
pub fn ConvertThreadToFiberEx(lpParameter: LPVOID, dwFlags: DWORD) -> LPVOID;
pub fn CopyContext(Destination: PCONTEXT, ContextFlags: DWORD, Source: PCONTEXT) -> BOOL;
pub fn CopyFile2(
pwszExistingFileName: PCWSTR, pwszNewFileName: PCWSTR,
pExtendedParameters: *mut COPYFILE2_EXTENDED_PARAMETERS,
) -> HRESULT;
pub fn CopyFileA(
lpExistingFileName: LPCSTR, lpNewFileName: LPCSTR, bFailIfExists: BOOL
) -> BOOL;
pub fn CopyFileExA(
lpExistingFileName: LPCSTR, lpNewFileName: LPCSTR, lpProgressRoutine: LPPROGRESS_ROUTINE,
lpData: LPVOID, pbCancel: LPBOOL, dwCopyFlags: DWORD,
) -> BOOL;
pub fn CopyFileExW(
lpExistingFileName: LPCWSTR, lpNewFileName: LPCWSTR, lpProgressRoutine: LPPROGRESS_ROUTINE,
lpData: LPVOID, pbCancel: LPBOOL, dwCopyFlags: DWORD,
) -> BOOL;
pub fn CopyFileTransactedA(
lpExistingFileName: LPCWSTR, lpNewFileName: LPCWSTR, lpProgressRoutine: LPPROGRESS_ROUTINE,
lpData: LPVOID, pbCancel: LPBOOL, dwCopyFlags: DWORD, hTransaction: HANDLE,
) -> BOOL;
pub fn CopyFileTransactedW(
lpExistingFileName: LPCWSTR, lpNewFileName: LPCWSTR, lpProgressRoutine: LPPROGRESS_ROUTINE,
lpData: LPVOID, pbCancel: LPBOOL, dwCopyFlags: DWORD, hTransaction: HANDLE,
) -> BOOL;
pub fn CopyFileW(
lpExistingFileName: LPCWSTR, lpNewFileName: LPCWSTR, bFailIfExists: BOOL
) -> BOOL;
pub fn CreateActCtxA(pActCtx: PCACTCTXA) -> HANDLE;
pub fn CreateActCtxW(pActCtx: PCACTCTXW) -> HANDLE;
pub fn CreateBoundaryDescriptorA(Name: LPCSTR, Flags: ULONG) -> HANDLE;
pub fn CreateBoundaryDescriptorW(Name: LPCWSTR, Flags: ULONG) -> HANDLE;
pub fn CreateConsoleScreenBuffer(
dwDesiredAccess: DWORD, dwShareMode: DWORD,
lpSecurityAttributes: *const SECURITY_ATTRIBUTES, dwFlags: DWORD,
lpScreenBufferData: LPVOID,
) -> HANDLE;
pub fn CreateDirectoryA(
lpPathName: LPCSTR, lpSecurityAttributes: LPSECURITY_ATTRIBUTES,
) -> BOOL;
pub fn CreateDirectoryExA(
lpTemplateDirectory: LPCSTR, lpNewDirectory: LPCSTR,
lpSecurityAttributes: LPSECURITY_ATTRIBUTES,
) -> BOOL;
pub fn CreateDirectoryExW(
lpTemplateDirectory: LPCWSTR, lpNewDirectory: LPCWSTR,
lpSecurityAttributes: LPSECURITY_ATTRIBUTES,
) -> BOOL;
pub fn CreateDirectoryTransactedA(
lpTemplateDirectory: LPCSTR, lpNewDirectory: LPCSTR,
lpSecurityAttributes: LPSECURITY_ATTRIBUTES, hTransaction: HANDLE,
) -> BOOL;
pub fn CreateDirectoryTransactedW(
lpTemplateDirectory: LPCWSTR, lpNewDirectory: LPCWSTR,
lpSecurityAttributes: LPSECURITY_ATTRIBUTES, hTransaction: HANDLE,
) -> BOOL;
pub fn CreateDirectoryW(
lpPathName: LPCWSTR, lpSecurityAttributes: LPSECURITY_ATTRIBUTES,
) -> BOOL;
pub fn CreateEventA(
lpEventAttributes: LPSECURITY_ATTRIBUTES, bManualReset: BOOL, bInitialState: BOOL,
lpName: LPCSTR,
) -> HANDLE;
pub fn CreateEventW(
lpEventAttributes: LPSECURITY_ATTRIBUTES, bManualReset: BOOL, bInitialState: BOOL,
lpName: LPCWSTR,
) -> HANDLE;
pub fn CreateEventExA(
lpEventAttributes: LPSECURITY_ATTRIBUTES, lpName: LPCSTR, dwFlags: DWORD,
dwDesiredAccess: DWORD,
) -> HANDLE;
pub fn CreateEventExW(
lpEventAttributes: LPSECURITY_ATTRIBUTES, lpName: LPWSTR, dwFlags: DWORD,
dwDesiredAccess: DWORD,
) -> HANDLE;
pub fn CreateFiber(
dwStackSize: SIZE_T, lpStartAddress: LPFIBER_START_ROUTINE, lpParameter: LPVOID,
) -> LPVOID;
pub fn CreateFiberEx(
dwStackCommitSize: SIZE_T, dwStackReserveSize: SIZE_T, dwFlags: DWORD,
lpStartAddress: LPFIBER_START_ROUTINE, lpParameter: LPVOID,
) -> LPVOID;
pub fn CreateFile2(
lpFileName: LPCWSTR, dwDesiredAccess: DWORD, dwShareMode: DWORD,
dwCreationDisposition: DWORD, pCreateExParams: LPCREATEFILE2_EXTENDED_PARAMETERS,
) -> HANDLE;
pub fn CreateFileA(
lpFileName: LPCSTR, dwDesiredAccess: DWORD, dwShareMode: DWORD,
lpSecurityAttributes: LPSECURITY_ATTRIBUTES, dwCreationDisposition: DWORD,
dwFlagsAndAttributes: DWORD, hTemplateFile: HANDLE,
) -> HANDLE;
pub fn CreateFileMappingA(
hFile: HANDLE, lpAttributes: LPSECURITY_ATTRIBUTES, flProtect: DWORD,
dwMaximumSizeHigh: DWORD, dwMaximumSizeLow: DWORD, lpName: LPCSTR,
) -> HANDLE;
pub fn CreateFileMappingFromApp(
hFile: HANDLE, SecurityAttributes: PSECURITY_ATTRIBUTES, PageProtection: ULONG,
MaximumSize: ULONG64, Name: PCWSTR,
) -> HANDLE;
pub fn CreateFileMappingNumaA(
hFile: HANDLE, lpFileMappingAttributes: LPSECURITY_ATTRIBUTES, flProtect: DWORD,
dwMaximumSizeHigh: DWORD, dwMaximumSizeLow: DWORD, lpName: LPCSTR, nndPreferred: DWORD,
) -> HANDLE;
pub fn CreateFileMappingNumaW(
hFile: HANDLE, lpFileMappingAttributes: LPSECURITY_ATTRIBUTES, flProtect: DWORD,
dwMaximumSizeHigh: DWORD, dwMaximumSizeLow: DWORD, lpName: LPCWSTR, nndPreferred: DWORD,
) -> HANDLE;
pub fn CreateFileMappingW(
hFile: HANDLE, lpAttributes: LPSECURITY_ATTRIBUTES, flProtect: DWORD,
dwMaximumSizeHigh: DWORD, dwMaximumSizeLow: DWORD, lpName: LPCWSTR,
) -> HANDLE;
pub fn CreateFileTransactedA(
lpFileName: LPCSTR, dwDesiredAccess: DWORD, dwShareMode: DWORD,
lpSecurityAttributes: LPSECURITY_ATTRIBUTES, dwCreationDisposition: DWORD,
dwFlagsAndAttributes: DWORD, hTemplateFile: HANDLE, hTransaction: HANDLE,
pusMiniVersion: PUSHORT, lpExtendedParameter: PVOID,
) -> HANDLE;
pub fn CreateFileTransactedW(
lpFileName: LPCWSTR, dwDesiredAccess: DWORD, dwShareMode: DWORD,
lpSecurityAttributes: LPSECURITY_ATTRIBUTES, dwCreationDisposition: DWORD,
dwFlagsAndAttributes: DWORD, hTemplateFile: HANDLE, hTransaction: HANDLE,
pusMiniVersion: PUSHORT, lpExtendedParameter: PVOID,
) -> HANDLE;
pub fn CreateFileW(
lpFileName: LPCWSTR, dwDesiredAccess: DWORD, dwShareMode: DWORD,
lpSecurityAttributes: LPSECURITY_ATTRIBUTES, dwCreationDisposition: DWORD,
dwFlagsAndAttributes: DWORD, hTemplateFile: HANDLE,
) -> HANDLE;
pub fn CreateHardLinkA(
lpFileName: LPCSTR, lpExistingFileName: LPCSTR, lpSecurityAttributes: LPSECURITY_ATTRIBUTES,
) -> BOOL;
pub fn CreateHardLinkTransactedA(
lpFileName: LPCSTR, lpExistingFileName: LPCSTR, lpSecurityAttributes: LPSECURITY_ATTRIBUTES,
hTransaction: HANDLE,
) -> BOOL;
pub fn CreateHardLinkTransactedW(
lpFileName: LPCWSTR, lpExistingFileName: LPCWSTR,
lpSecurityAttributes: LPSECURITY_ATTRIBUTES, hTransaction: HANDLE,
);
pub fn CreateHardLinkW(
lpFileName: LPCWSTR, lpExistingFileName: LPCWSTR,
lpSecurityAttributes: LPSECURITY_ATTRIBUTES,
) -> BOOL;
pub fn CreateIoCompletionPort(
FileHandle: HANDLE, ExistingCompletionPort: HANDLE, CompletionKey: ULONG_PTR,
NumberOfConcurrentThreads: DWORD,
) -> HANDLE;
pub fn CreateJobObjectA(lpJobAttributes: LPSECURITY_ATTRIBUTES, lpName: LPCSTR) -> HANDLE;
pub fn CreateJobObjectW(lpJobAttributes: LPSECURITY_ATTRIBUTES, lpName: LPCWSTR) -> HANDLE;
pub fn CreateJobSet(NumJob: ULONG, UserJobSet: PJOB_SET_ARRAY, Flags: ULONG) -> BOOL;
pub fn CreateMailslotA(
lpName: LPCSTR, nMaxMessageSize: DWORD, lReadTimeout: DWORD,
lpSecurityAttributes: LPSECURITY_ATTRIBUTES,
) -> HANDLE;
pub fn CreateMailslotW(
lpName: LPCWSTR, nMaxMessageSize: DWORD, lReadTimeout: DWORD,
lpSecurityAttributes: LPSECURITY_ATTRIBUTES,
) -> HANDLE;
pub fn CreateMemoryResourceNotification(
NotificationType: MEMORY_RESOURCE_NOTIFICATION_TYPE,
) -> HANDLE;
pub fn CreateMutexA(
lpMutexAttributes: LPSECURITY_ATTRIBUTES, bInitialOwner: BOOL, lpName: LPCSTR,
) -> HANDLE;
pub fn CreateMutexExA(
lpMutexAttributes: LPSECURITY_ATTRIBUTES, lpName: LPCSTR, dwFlags: DWORD,
dwDesiredAccess: DWORD,
) -> HANDLE;
pub fn CreateMutexExW(
lpMutexAttributes: LPSECURITY_ATTRIBUTES, lpName: LPCWSTR, dwFlags: DWORD,
dwDesiredAccess: DWORD,
) -> HANDLE;
pub fn CreateMutexW(
lpMutexAttributes: LPSECURITY_ATTRIBUTES, bInitialOwner: BOOL, lpName: LPCWSTR,
) -> HANDLE;
pub fn CreateNamedPipeA(
lpName: LPCSTR, dwOpenMode: DWORD, dwPipeMode: DWORD, nMaxInstances: DWORD,
nOutBufferSize: DWORD, nInBufferSize: DWORD, nDefaultTimeOut: DWORD,
lpSecurityAttributes: LPSECURITY_ATTRIBUTES,
) -> HANDLE;
pub fn CreateNamedPipeW(
lpName: LPCWSTR, dwOpenMode: DWORD, dwPipeMode: DWORD, nMaxInstances: DWORD,
nOutBufferSize: DWORD, nInBufferSize: DWORD, nDefaultTimeOut: DWORD,
lpSecurityAttributes: LPSECURITY_ATTRIBUTES,
) -> HANDLE;
pub fn CreatePipe(
hReadPipe: PHANDLE, hWritePipe: PHANDLE, lpPipeAttributes: LPSECURITY_ATTRIBUTES,
nSize: DWORD,
) -> BOOL;
pub fn CreatePrivateNamespaceA(
lpPrivateNamespaceAttributes: LPSECURITY_ATTRIBUTES, lpBoundaryDescriptor: LPVOID,
lpAliasPrefix: LPCSTR,
) -> HANDLE;
pub fn CreatePrivateNamespaceW(
lpPrivateNamespaceAttributes: LPSECURITY_ATTRIBUTES, lpBoundaryDescriptor: LPVOID,
lpAliasPrefix: LPCWSTR,
) -> HANDLE;
pub fn CreateProcessA(
lpApplicationName: LPCSTR, lpCommandLine: LPSTR, lpProcessAttributes: LPSECURITY_ATTRIBUTES,
lpThreadAttributes: LPSECURITY_ATTRIBUTES, bInheritHandles: BOOL, dwCreationFlags: DWORD,
lpEnvironment: LPVOID, lpCurrentDirectory: LPCSTR, lpStartupInfo: LPSTARTUPINFOA,
lpProcessInformation: LPPROCESS_INFORMATION,
) -> BOOL;
pub fn CreateProcessW(
lpApplicationName: LPCWSTR, lpCommandLine: LPWSTR,
lpProcessAttributes: LPSECURITY_ATTRIBUTES, lpThreadAttributes: LPSECURITY_ATTRIBUTES,
bInheritHandles: BOOL, dwCreationFlags: DWORD, lpEnvironment: LPVOID,
lpCurrentDirectory: LPCWSTR, lpStartupInfo: LPSTARTUPINFOW,
lpProcessInformation: LPPROCESS_INFORMATION,
) -> BOOL;
pub fn CreateRemoteThread(
hProcess: HANDLE, lpThreadAttributes: LPSECURITY_ATTRIBUTES, dwStackSize: SIZE_T,
lpStartAddress: LPTHREAD_START_ROUTINE, lpParameter: LPVOID, dwCreationFlags: DWORD,
lpThreadId: LPDWORD,
) -> HANDLE;
pub fn CreateRemoteThreadEx(
hProcess: HANDLE, lpThreadAttributes: LPSECURITY_ATTRIBUTES, dwStackSize: SIZE_T,
lpStartAddress: LPTHREAD_START_ROUTINE, lpParameter: LPVOID, dwCreationFlags: DWORD,
lpAttributeList: LPPROC_THREAD_ATTRIBUTE_LIST, lpThreadId: LPDWORD,
) -> HANDLE;
pub fn CreateSemaphoreA(
lpSemaphoreAttributes: LPSECURITY_ATTRIBUTES, lInitialCount: LONG, lMaximumCount: LONG,
lpName: LPCSTR,
) -> HANDLE;
pub fn CreateSemaphoreExA(
lpSemaphoreAttributes: LPSECURITY_ATTRIBUTES, lInitialCount: LONG, lMaximumCount: LONG,
lpName: LPCSTR, dwFlags: DWORD, dwDesiredAccess: DWORD,
) -> HANDLE;
pub fn CreateSemaphoreExW(
lpSemaphoreAttributes: LPSECURITY_ATTRIBUTES, lInitialCount: LONG, lMaximumCount: LONG,
lpName: LPCWSTR, dwFlags: DWORD, dwDesiredAccess: DWORD,
) -> HANDLE;
pub fn CreateSemaphoreW(
lpSemaphoreAttributes: LPSECURITY_ATTRIBUTES, lInitialCount: LONG, lMaximumCount: LONG,
lpName: LPCWSTR,
) -> HANDLE;
pub fn CreateSymbolicLinkA(
lpSymlinkFileName: LPCSTR, lpTargetFileName: LPCSTR, dwFlags: DWORD,
) -> BOOLEAN;
pub fn CreateSymbolicLinkTransactedA(
lpSymlinkFileName: LPCSTR, lpTargetFileName: LPCSTR, dwFlags: DWORD, hTransaction: HANDLE,
) -> BOOLEAN;
pub fn CreateSymbolicLinkTransactedW(
lpSymlinkFileName: LPCWSTR, lpTargetFileName: LPCWSTR, dwFlags: DWORD, hTransaction: HANDLE,
) -> BOOLEAN;
pub fn CreateSymbolicLinkW(
lpSymlinkFileName: LPCWSTR, lpTargetFileName: LPCWSTR, dwFlags: DWORD,
) -> BOOLEAN;
pub fn CreateTapePartition(
hDevice: HANDLE, dwPartitionMethod: DWORD, dwCount: DWORD, dwSize: DWORD,
) -> DWORD;
pub fn CreateThread(
lpThreadAttributes: LPSECURITY_ATTRIBUTES, dwStackSize: SIZE_T,
lpStartAddress: LPTHREAD_START_ROUTINE, lpParameter: LPVOID, dwCreationFlags: DWORD,
lpThreadId: LPDWORD,
) -> HANDLE;
pub fn CreateThreadpool(reserved: PVOID) -> PTP_POOL;
pub fn CreateThreadpoolCleanupGroup() -> PTP_CLEANUP_GROUP;
pub fn CreateThreadpoolIo(
fl: HANDLE, pfnio: PTP_WIN32_IO_CALLBACK, pv: PVOID, pcbe: PTP_CALLBACK_ENVIRON,
) -> PTP_IO;
pub fn CreateThreadpoolTimer(
pfnti: PTP_TIMER_CALLBACK, pv: PVOID, pcbe: PTP_CALLBACK_ENVIRON,
) -> PTP_TIMER;
pub fn CreateThreadpoolWait(
pfnwa: PTP_WAIT_CALLBACK, pv: PVOID, pcbe: PTP_CALLBACK_ENVIRON,
) -> PTP_WAIT;
pub fn CreateThreadpoolWork(
pfnwk: PTP_WORK_CALLBACK, pv: PVOID, pcbe: PTP_CALLBACK_ENVIRON,
) -> PTP_WORK;
pub fn CreateTimerQueue() -> HANDLE;
pub fn CreateTimerQueueTimer(
phNewTimer: PHANDLE, TimerQueue: HANDLE, Callback: WAITORTIMERCALLBACK, Parameter: PVOID,
DueTime: DWORD, Period: DWORD, Flags: ULONG,
) -> BOOL;
pub fn CreateToolhelp32Snapshot(dwFlags: DWORD, th32ProcessID: DWORD) -> HANDLE;
#[cfg(target_arch = "x86_64")]
pub fn CreateUmsCompletionList(UmsCompletionList: *mut PUMS_COMPLETION_LIST) -> BOOL;
#[cfg(target_arch = "x86_64")]
pub fn CreateUmsThreadContext(lpUmsThread: *mut PUMS_CONTEXT) -> BOOL;
pub fn CreateWaitableTimerA(
lpTimerAttributes: LPSECURITY_ATTRIBUTES, bManualReset: BOOL, lpTimerName: LPCSTR,
) -> HANDLE;
pub fn CreateWaitableTimerExA(
lpTimerAttributes: LPSECURITY_ATTRIBUTES, lpTimerName: LPCSTR, dwFlags: DWORD,
dwDesiredAccess: DWORD,
) -> HANDLE;
pub fn CreateWaitableTimerExW(
lpTimerAttributes: LPSECURITY_ATTRIBUTES, lpTimerName: LPCWSTR, dwFlags: DWORD,
dwDesiredAccess: DWORD,
) -> HANDLE;
pub fn CreateWaitableTimerW(
lpTimerAttributes: LPSECURITY_ATTRIBUTES, bManualReset: BOOL, lpTimerName: LPCWSTR,
) -> HANDLE;
pub fn DeactivateActCtx(dwFlags: DWORD, ulCookie: ULONG_PTR) -> BOOL;
pub fn DebugActiveProcess(dwProcessId: DWORD) -> BOOL;
pub fn DebugActiveProcessStop(dwProcessId: DWORD) -> BOOL;
pub fn DebugBreak();
pub fn DebugBreakProcess(Process: HANDLE) -> BOOL;
pub fn DebugSetProcessKillOnExit(KillOnExit: BOOL) -> BOOL;
pub fn DecodePointer(Ptr: PVOID) -> PVOID;
pub fn DecodeSystemPointer(Ptr: PVOID) -> PVOID;
pub fn DefineDosDeviceA(dwFlags: DWORD, lpDeviceName: LPCSTR, lpTargetPath: LPCSTR) -> BOOL;
pub fn DefineDosDeviceW(dwFlags: DWORD, lpDeviceName: LPCWSTR, lpTargetPath: LPCWSTR) -> BOOL;
pub fn DelayLoadFailureHook(pszDllName: LPCSTR, pszProcName: LPCSTR);
pub fn DeleteAtom(nAtom: ATOM) -> ATOM;
pub fn DeleteBoundaryDescriptor(BoundaryDescriptor: HANDLE);
pub fn DeleteCriticalSection(lpCriticalSection: LPCRITICAL_SECTION);
pub fn DeleteFiber(lpFiber: LPVOID);
pub fn DeleteFileA(lpFileName: LPCSTR) -> BOOL;
pub fn DeleteFileTransactedA(lpFileName: LPCSTR, hTransaction: HANDLE) -> BOOL;
pub fn DeleteFileTransactedW(lpFileName: LPCWSTR, hTransaction: HANDLE) -> BOOL;
pub fn DeleteFileW(lpFileName: LPCWSTR) -> BOOL;
pub fn DeleteProcThreadAttributeList(lpAttributeList: LPPROC_THREAD_ATTRIBUTE_LIST);
pub fn DeleteSynchronizationBarrier(lpBarrier: LPSYNCHRONIZATION_BARRIER) -> BOOL;
pub fn DeleteTimerQueue(TimerQueue: HANDLE) -> BOOL;
pub fn DeleteTimerQueueEx(TimerQueue: HANDLE, CompletionEvent: HANDLE) -> BOOL;
pub fn DeleteTimerQueueTimer(
TimerQueue: HANDLE, Timer: HANDLE, CompletionEvent: HANDLE,
) -> BOOL;
#[cfg(target_arch = "x86_64")]
pub fn DeleteUmsCompletionList(UmsCompletionList: PUMS_COMPLETION_LIST) -> BOOL;
#[cfg(target_arch = "x86_64")]
pub fn DeleteUmsThreadContext(UmsThread: PUMS_CONTEXT) -> BOOL;
pub fn DeleteVolumeMountPointA(lpszVolumeMountPoint: LPCSTR) -> BOOL;
pub fn DeleteVolumeMountPointW(lpszVolumeMountPoint: LPCWSTR) -> BOOL;
#[cfg(target_arch = "x86_64")]
pub fn DequeueUmsCompletionListItems(
UmsCompletionList: PUMS_COMPLETION_LIST, WaitTimeOut: DWORD,
UmsThreadList: *mut PUMS_CONTEXT,
) -> BOOL;
pub fn DeviceIoControl(
hDevice: HANDLE, dwIoControlCode: DWORD, lpInBuffer: LPVOID, nInBufferSize: DWORD,
lpOutBuffer: LPVOID, nOutBufferSize: DWORD, lpBytesReturned: LPDWORD,
lpOverlapped: LPOVERLAPPED,
) -> BOOL;
pub fn DisableThreadLibraryCalls(hLibModule: HMODULE) -> BOOL;
pub fn DisableThreadProfiling(PerformanceDataHandle: HANDLE) -> DWORD;
pub fn DisassociateCurrentThreadFromCallback(pci: PTP_CALLBACK_INSTANCE);
pub fn DisconnectNamedPipe(hNamedPipe: HANDLE) -> BOOL;
pub fn DnsHostnameToComputerNameA(
Hostname: LPCSTR, ComputerName: LPCSTR, nSize: LPDWORD,
) -> BOOL;
pub fn DnsHostnameToComputerNameExW(
Hostname: LPCWSTR, ComputerName: LPWSTR, nSize: LPDWORD,
) -> BOOL;
pub fn DnsHostnameToComputerNameW(
Hostname: LPCWSTR, ComputerName: LPWSTR, nSize: LPDWORD,
) -> BOOL;
pub fn DosDateTimeToFileTime(wFatDate: WORD, wFatTime: WORD, lpFileTime: LPFILETIME) -> BOOL;
pub fn DuplicateHandle(
hSourceProcessHandle: HANDLE, hSourceHandle: HANDLE, hTargetProcessHandle: HANDLE,
lpTargetHandle: LPHANDLE, dwDesiredAccess: DWORD, bInheritHandle: BOOL, dwOptions: DWORD,
) -> BOOL;
pub fn EnableThreadProfiling(
ThreadHandle: HANDLE, Flags: DWORD, HardwareCounters: DWORD64,
PerformanceDataHandle: *mut HANDLE,
) -> BOOL;
pub fn EncodePointer(Ptr: PVOID) -> PVOID;
pub fn EncodeSystemPointer(Ptr: PVOID) -> PVOID;
pub fn EndUpdateResourceA(hUpdate: HANDLE, fDiscard: BOOL) -> BOOL;
pub fn EndUpdateResourceW(hUpdate: HANDLE, fDiscard: BOOL) -> BOOL;
pub fn EnterCriticalSection(lpCriticalSection: LPCRITICAL_SECTION);
pub fn EnterSynchronizationBarrier(
lpBarrier: LPSYNCHRONIZATION_BARRIER, dwFlags: DWORD,
) -> BOOL;
#[cfg(target_arch = "x86_64")]
pub fn EnterUmsSchedulingMode(SchedulerStartupInfo: PUMS_SCHEDULER_STARTUP_INFO) -> BOOL;
pub fn EnumCalendarInfoA(
lpCalInfoEnumProc: CALINFO_ENUMPROCA, Locale: LCID, Calendar: CALID, CalType: CALTYPE,
) -> BOOL;
pub fn EnumCalendarInfoExA(
lpCalInfoEnumProcEx: CALINFO_ENUMPROCEXA, Locale: LCID, Calendar: CALID, CalType: CALTYPE,
) -> BOOL;
pub fn EnumCalendarInfoExEx(
pCalInfoEnumProcExEx: CALINFO_ENUMPROCEXEX, lpLocaleName: LPCWSTR, Calendar: CALID,
lpReserved: LPCWSTR, CalType: CALTYPE, lParam: LPARAM,
) -> BOOL;
pub fn EnumCalendarInfoExW(
lpCalInfoEnumProcEx: CALINFO_ENUMPROCEXW, Locale: LCID, Calendar: CALID, CalType: CALTYPE,
) -> BOOL;
pub fn EnumCalendarInfoW(
lpCalInfoEnumProc: CALINFO_ENUMPROCW, Locale: LCID, Calendar: CALID, CalType: CALTYPE,
) -> BOOL;
pub fn EnumDateFormatsA(
lpDateFmtEnumProc: DATEFMT_ENUMPROCA, Locale: LCID, dwFlags: DWORD,
) -> BOOL;
pub fn EnumDateFormatsExA(
lpDateFmtEnumProcEx: DATEFMT_ENUMPROCEXA, Locale: LCID, dwFlags: DWORD,
) -> BOOL;
pub fn EnumDateFormatsExEx(
lpDateFmtEnumProcExEx: DATEFMT_ENUMPROCEXEX, lpLocaleName: LPCWSTR, dwFlags: DWORD,
lParam: LPARAM,
) -> BOOL;
pub fn EnumDateFormatsExW(
lpDateFmtEnumProcEx: DATEFMT_ENUMPROCEXW, Locale: LCID, dwFlags: DWORD,
) -> BOOL;
pub fn EnumDateFormatsW(
lpDateFmtEnumProc: DATEFMT_ENUMPROCW, Locale: LCID, dwFlags: DWORD,
) -> BOOL;
pub fn EnumLanguageGroupLocalesA(
lpLangGroupLocaleEnumProc: LANGGROUPLOCALE_ENUMPROCA, LanguageGroup: LGRPID, dwFlags: DWORD,
lParam: LONG_PTR,
) -> BOOL;
pub fn EnumLanguageGroupLocalesW(
lpLangGroupLocaleEnumProc: LANGGROUPLOCALE_ENUMPROCW, LanguageGroup: LGRPID, dwFlags: DWORD,
lParam: LONG_PTR,
) -> BOOL;
pub fn EnumResourceLanguagesA(
hModule: HMODULE, lpType: LPCSTR, lpName: LPCSTR, lpEnumFunc: ENUMRESLANGPROCA,
lParam: LONG_PTR,
) -> BOOL;
pub fn EnumResourceLanguagesExA(
hModule: HMODULE, lpType: LPCSTR, lpName: LPCSTR, lpEnumFunc: ENUMRESLANGPROCA,
lParam: LONG_PTR, dwFlags: DWORD, LangId: LANGID,
) -> BOOL;
pub fn EnumResourceLanguagesExW(
hModule: HMODULE, lpType: LPCWSTR, lpName: LPCWSTR, lpEnumFunc: ENUMRESLANGPROCW,
lParam: LONG_PTR, dwFlags: DWORD, LangId: LANGID,
) -> BOOL;
pub fn EnumResourceLanguagesW(
hModule: HMODULE, lpType: LPCWSTR, lpName: LPCWSTR, lpEnumFunc: ENUMRESLANGPROCW,
lParam: LONG_PTR,
) -> BOOL;
pub fn EnumResourceNamesA(
hModule: HMODULE, lpType: LPCSTR, lpEnumFunc: ENUMRESNAMEPROCA, lParam: LONG_PTR,
) -> BOOL;
pub fn EnumResourceNamesExA(
hModule: HMODULE, lpType: LPCSTR, lpEnumFunc: ENUMRESNAMEPROCA, lParam: LONG_PTR,
dwFlags: DWORD, LangId: LANGID,
) -> BOOL;
pub fn EnumResourceNamesExW(
hModule: HMODULE, lpType: LPCWSTR, lpEnumFunc: ENUMRESNAMEPROCW, lParam: LONG_PTR,
dwFlags: DWORD, LangId: LANGID,
) -> BOOL;
pub fn EnumResourceNamesW(
hModule: HMODULE, lpType: LPCWSTR, lpEnumFunc: ENUMRESNAMEPROCW, lParam: LONG_PTR,
) -> BOOL;
pub fn EnumResourceTypesA(
hModule: HMODULE, lpEnumFunc: ENUMRESTYPEPROCA, lParam: LONG_PTR,
) -> BOOL;
pub fn EnumResourceTypesExA(
hModule: HMODULE, lpEnumFunc: ENUMRESTYPEPROCA, lParam: LONG_PTR, dwFlags: DWORD,
LangId: LANGID,
) -> BOOL;
pub fn EnumResourceTypesExW(
hModule: HMODULE, lpEnumFunc: ENUMRESTYPEPROCW, lParam: LONG_PTR, dwFlags: DWORD,
LangId: LANGID,
) -> BOOL;
pub fn EnumResourceTypesW(
hModule: HMODULE, lpEnumFunc: ENUMRESTYPEPROCW, lParam: LONG_PTR,
) -> BOOL;
pub fn EnumSystemCodePagesA(lpCodePageEnumProc: CODEPAGE_ENUMPROCA, dwFlags: DWORD) -> BOOL;
pub fn EnumSystemCodePagesW(lpCodePageEnumProc: CODEPAGE_ENUMPROCW, dwFlags: DWORD) -> BOOL;
pub fn EnumSystemFirmwareTables(
FirmwareTableProviderSignature: DWORD, pFirmwareTableEnumBuffer: PVOID, BufferSize: DWORD,
) -> UINT;
pub fn EnumSystemGeoID(
GeoClass: GEOCLASS, ParentGeoId: GEOID, lpGeoEnumProc: GEO_ENUMPROC,
) -> BOOL;
pub fn EnumSystemLanguageGroupsA(
lpLanguageGroupEnumProc: LANGUAGEGROUP_ENUMPROCA, dwFlags: DWORD, lParam: LONG_PTR,
) -> BOOL;
pub fn EnumSystemLanguageGroupsW(
lpLanguageGroupEnumProc: LANGUAGEGROUP_ENUMPROCW, dwFlags: DWORD, lParam: LONG_PTR,
) -> BOOL;
pub fn EnumSystemLocalesA(lpLocaleEnumProc: LOCALE_ENUMPROCA, dwFlags: DWORD) -> BOOL;
pub fn EnumSystemLocalesEx(
lpLocaleEnumProcEx: LOCALE_ENUMPROCEX, dwFlags: DWORD, lParam: LPARAM, lpReserved: LPVOID,
) -> BOOL;
pub fn EnumSystemLocalesW(lpLocaleEnumProc: LOCALE_ENUMPROCW, dwFlags: DWORD) -> BOOL;
pub fn EnumTimeFormatsA(
lpTimeFmtEnumProc: TIMEFMT_ENUMPROCA, Locale: LCID, dwFlags: DWORD,
) -> BOOL;
pub fn EnumTimeFormatsEx(
lpTimeFmtEnumProcEx: TIMEFMT_ENUMPROCEX, lpLocaleName: LPCWSTR, dwFlags: DWORD,
lParam: LPARAM,
) -> BOOL;
pub fn EnumTimeFormatsW(
lpTimeFmtEnumProc: TIMEFMT_ENUMPROCW, Locale: LCID, dwFlags: DWORD,
) -> BOOL;
pub fn EnumUILanguagesA(
lpUILanguageEnumProc: UILANGUAGE_ENUMPROCA, dwFlags: DWORD, lParam: LONG_PTR,
) -> BOOL;
pub fn EnumUILanguagesW(
lpUILanguageEnumProc: UILANGUAGE_ENUMPROCW, dwFlags: DWORD, lParam: LONG_PTR,
) -> BOOL;
pub fn EraseTape(hDevice: HANDLE, dwEraseType: DWORD, bImmediate: BOOL) -> DWORD;
pub fn EscapeCommFunction(hFile: HANDLE, dwFunc: DWORD) -> BOOL;
#[cfg(target_arch = "x86_64")]
pub fn ExecuteUmsThread(UmsThread: PUMS_CONTEXT) -> BOOL;
pub fn ExitProcess(uExitCode: UINT);
pub fn ExitThread(hThread: HANDLE, lpExitCode: LPDWORD) -> BOOL;
pub fn ExpandEnvironmentStringsA(lpSrc: LPCSTR, lpDst: LPSTR, nSize: DWORD) -> DWORD;
pub fn ExpandEnvironmentStringsW(lpSrc: LPCWSTR, lpDst: LPWSTR, nSize: DWORD) -> DWORD;
pub fn FatalAppExitA(uAction: UINT, lpMessageText: LPCSTR);
pub fn FatalAppExitW(uAction: UINT, lpMessageText: LPCWSTR);
pub fn FatalExit(ExitCode: c_int);
pub fn FileTimeToDosDateTime(
lpFileTime: *const FILETIME, lpFatDate: LPWORD, lpFatTime: LPWORD,
) -> BOOL;
pub fn FileTimeToLocalFileTime(
lpFileTime: *const FILETIME, lpLocalFileTime: LPFILETIME,
) -> BOOL;
pub fn FileTimeToSystemTime(
lpFileTime: *const FILETIME, lpSystemTime: LPSYSTEMTIME,
) -> BOOL;
pub fn FillConsoleOutputAttribute(
hConsoleOutput: HANDLE, wAttribute: WORD, nLength: DWORD, dwWriteCoord: COORD,
lpNumberOfAttrsWritten: LPDWORD,
) -> BOOL;
pub fn FillConsoleOutputCharacterA(
hConsoleOutput: HANDLE, cCharacter: CHAR, nLength: DWORD, dwWriteCoord: COORD,
lpNumberOfCharsWritten: LPDWORD,
) -> BOOL;
pub fn FillConsoleOutputCharacterW(
hConsoleOutput: HANDLE, cCharacter: WCHAR, nLength: DWORD, dwWriteCoord: COORD,
lpNumberOfCharsWritten: LPDWORD,
) -> BOOL;
pub fn FindActCtxSectionGuid(
dwFlags: DWORD, lpExtensionGuid: *const GUID, ulSectionId: ULONG, lpGuidToFind: *const GUID,
ReturnedData: PACTCTX_SECTION_KEYED_DATA,
) -> BOOL;
pub fn FindActCtxSectionStringA(
dwFlags: DWORD, lpExtensionGuid: *const GUID, ulSectionId: ULONG, lpStringToFind: LPCSTR,
ReturnedData: PACTCTX_SECTION_KEYED_DATA,
) -> BOOL;
pub fn FindActCtxSectionStringW(
dwFlags: DWORD, lpExtensionGuid: *const GUID, ulSectionId: ULONG, lpStringToFind: LPCWSTR,
ReturnedData: PACTCTX_SECTION_KEYED_DATA,
) -> BOOL;
pub fn FindAtomA(lpString: LPCSTR) -> ATOM;
pub fn FindAtomW(lpString: LPCWSTR) -> ATOM;
pub fn FindClose(hFindFile: HANDLE) -> BOOL;
pub fn FindCloseChangeNotification(hChangeHandle: HANDLE) -> BOOL;
pub fn FindFirstChangeNotificationA(
lpPathName: LPCSTR, bWatchSubtree: BOOL, dwNotifyFilter: DWORD,
) -> HANDLE;
pub fn FindFirstChangeNotificationW(
lpPathName: LPCWSTR, bWatchSubtree: BOOL, dwNotifyFilter: DWORD,
) -> HANDLE;
pub fn FindFirstFileA(lpFileName: LPCSTR, lpFindFileData: LPWIN32_FIND_DATAA) -> HANDLE;
pub fn FindFirstFileExA(
lpFileName: LPCSTR, fInfoLevelId: FINDEX_INFO_LEVELS, lpFindFileData: LPVOID,
fSearchOp: FINDEX_SEARCH_OPS, lpSearchFilter: LPVOID, dwAdditionalFlags: DWORD,
) -> HANDLE;
pub fn FindFirstFileExW(
lpFileName: LPCWSTR, fInfoLevelId: FINDEX_INFO_LEVELS, lpFindFileData: LPVOID,
fSearchOp: FINDEX_SEARCH_OPS, lpSearchFilter: LPVOID, dwAdditionalFlags: DWORD,
) -> HANDLE;
pub fn FindFirstFileNameTransactedW(
lpFileName: LPCWSTR, dwFlags: DWORD, StringLength: LPDWORD, LinkName: PWSTR,
hTransaction: HANDLE,
) -> HANDLE;
pub fn FindFirstFileNameW(
lpFileName: LPCWSTR, dwFlags: DWORD, StringLength: LPDWORD, LinkName: PWSTR,
) -> HANDLE;
pub fn FindFirstFileTransactedA(
lpFileName: LPCSTR, fInfoLevelId: FINDEX_INFO_LEVELS, lpFindFileData: LPVOID,
fSearchOp: FINDEX_SEARCH_OPS, lpSearchFilter: LPVOID, dwAdditionalFlags: DWORD,
hTransaction: HANDLE,
) -> HANDLE;
pub fn FindFirstFileTransactedW(
lpFileName: LPCWSTR, fInfoLevelId: FINDEX_INFO_LEVELS, lpFindFileData: LPVOID,
fSearchOp: FINDEX_SEARCH_OPS, lpSearchFilter: LPVOID, dwAdditionalFlags: DWORD,
hTransaction: HANDLE,
) -> HANDLE;
pub fn FindFirstFileW(lpFileName: LPCWSTR, lpFindFileData: LPWIN32_FIND_DATAW) -> HANDLE;
pub fn FindFirstStreamTransactedW(
lpFileName: LPCWSTR, InfoLevel: STREAM_INFO_LEVELS, lpFindStreamData: LPVOID,
dwFlags: DWORD, hTransaction: HANDLE,
) -> HANDLE;
pub fn FindFirstStreamW(
lpFileName: LPCWSTR, InfoLevel: STREAM_INFO_LEVELS, lpFindStreamData: LPVOID,
dwFlags: DWORD,
) -> HANDLE;
pub fn FindFirstVolumeA(lpszVolumeName: LPSTR, cchBufferLength: DWORD) -> HANDLE;
pub fn FindFirstVolumeMountPointA(
lpszRootPathName: LPCSTR, lpszVolumeMountPoint: LPSTR, cchBufferLength: DWORD,
) -> HANDLE;
pub fn FindFirstVolumeMountPointW(
lpszRootPathName: LPCWSTR, lpszVolumeMountPoint: LPWSTR, cchBufferLength: DWORD,
) -> HANDLE;
pub fn FindFirstVolumeW(lpszVolumeName: LPWSTR, cchBufferLength: DWORD) -> HANDLE;
pub fn FindNLSString(
Locale: LCID, dwFindNLSStringFlags: DWORD, lpStringSource: LPCWSTR, cchSource: c_int,
lpStringValue: LPCWSTR, cchValue: c_int, pcchFound: LPINT,
) -> c_int;
pub fn FindNLSStringEx(
lpLocaleName: LPCWSTR, dwFindNLSStringFlags: DWORD, lpStringSource: LPCWSTR,
cchSource: c_int, lpStringValue: LPCWSTR, cchValue: c_int, pcchFound: LPINT,
lpVersionInformation: LPNLSVERSIONINFO, lpReserved: LPVOID, sortHandle: LPARAM,
) -> c_int;
pub fn FindNextChangeNotification(hChangeHandle: HANDLE) -> BOOL;
pub fn FindNextFileA(hFindFile: HANDLE, lpFindFileData: LPWIN32_FIND_DATAA) -> BOOL;
pub fn FindNextFileNameW(hFindStream: HANDLE, StringLength: LPDWORD, LinkName: PWSTR) -> BOOL;
pub fn FindNextFileW(hFindFile: HANDLE, lpFindFileData: LPWIN32_FIND_DATAW) -> BOOL;
pub fn FindNextStreamW(hFindStream: HANDLE, lpFindStreamData: LPVOID) -> BOOL;
pub fn FindNextVolumeA(
hFindVolume: HANDLE, lpszVolumeName: LPSTR, cchBufferLength: DWORD,
) -> BOOL;
pub fn FindNextVolumeMountPointA(
hFindVolumeMountPoint: HANDLE, lpszVolumeMountPoint: LPSTR, cchBufferLength: DWORD,
) -> BOOL;
pub fn FindNextVolumeMountPointW(
hFindVolumeMountPoint: HANDLE, lpszVolumeMountPoint: LPWSTR, cchBufferLength: DWORD,
) -> BOOL;
pub fn FindNextVolumeW(
hFindVolume: HANDLE, lpszVolumeName: LPWSTR, cchBufferLength: DWORD,
) -> BOOL;
pub fn FindResourceA(hModule: HMODULE, lpName: LPCSTR, lpType: LPCSTR) -> HRSRC;
pub fn FindResourceExA(
hModule: HMODULE, lpName: LPCSTR, lpType: LPCSTR, wLanguage: WORD,
) -> HRSRC;
pub fn FindResourceExW(
hModule: HMODULE, lpName: LPCWSTR, lpType: LPCWSTR, wLanguage: WORD,
) -> HRSRC;
pub fn FindResourceW(hModule: HMODULE, lpName: LPCWSTR, lpType: LPCWSTR) -> HRSRC;
pub fn FindStringOrdinal(
dwFindStringOrdinalFlags: DWORD, lpStringSource: LPCWSTR, cchSource: c_int,
lpStringValue: LPCWSTR, cchValue: c_int, bIgnoreCase: BOOL,
) -> c_int;
pub fn FindVolumeClose(hFindVolume: HANDLE) -> BOOL;
pub fn FindVolumeMountPointClose(hFindVolumeMountPoint: HANDLE) -> BOOL;
pub fn FlsAlloc(lpCallback: PFLS_CALLBACK_FUNCTION) -> DWORD;
pub fn FlsFree(dwFlsIndex: DWORD) -> BOOL;
pub fn FlsGetValue(dwFlsIndex: DWORD) -> PVOID;
pub fn FlsSetValue(dwFlsIndex: DWORD, lpFlsData: PVOID) -> BOOL;
pub fn FlushConsoleInputBuffer(hConsoleInput: HANDLE) -> BOOL;
pub fn FlushFileBuffers(hFile: HANDLE) -> BOOL;
pub fn FlushInstructionCache(hProcess: HANDLE, lpBaseAddress: LPCVOID, dwSize: SIZE_T) -> BOOL;
pub fn FlushProcessWriteBuffers();
pub fn FlushViewOfFile(lpBaseAddress: LPCVOID, dwNumberOfBytesToFlush: SIZE_T) -> BOOL;
pub fn FoldStringA(
dwMapFlags: DWORD, lpSrcStr: LPCSTR, cchSrc: c_int, lpDestStr: LPSTR, cchDest: c_int,
) -> c_int;
pub fn FoldStringW(
dwMapFlags: DWORD, lpSrcStr: LPCWCH, cchSrc: c_int, lpDestStr: LPWSTR, cchDest: c_int,
) -> c_int;
pub fn FormatMessageA(
dwFlags: DWORD, lpSource: LPCVOID, dwMessageId: DWORD, dwLanguageId: DWORD,
lpBuffer: LPSTR, nSize: DWORD, Arguments: *mut va_list,
) -> DWORD;
pub fn FormatMessageW(
dwFlags: DWORD, lpSource: LPCVOID, dwMessageId: DWORD, dwLanguageId: DWORD,
lpBuffer: LPWSTR, nSize: DWORD, Arguments: *mut va_list,
) -> DWORD;
pub fn FreeConsole() -> BOOL;
pub fn FreeEnvironmentStringsA(penv: LPCH) -> BOOL;
pub fn FreeEnvironmentStringsW(penv: LPWCH) -> BOOL;
pub fn FreeLibrary(hLibModule: HMODULE) -> BOOL;
pub fn FreeLibraryAndExitThread(hLibModule: HMODULE, dwExitCode: DWORD);
pub fn FreeLibraryWhenCallbackReturns(pci: PTP_CALLBACK_INSTANCE, module: HMODULE);
pub fn FreeResource(hResData: HGLOBAL) -> BOOL;
pub fn FreeUserPhysicalPages(
hProcess: HANDLE, NumberOfPages: PULONG_PTR, PageArray: PULONG_PTR,
) -> BOOL;
pub fn GenerateConsoleCtrlEvent(dwCtrlEvent: DWORD, dwProcessGroupId: DWORD) -> BOOL;
pub fn GetACP() -> UINT;
pub fn GetActiveProcessorCount(GroupNumber: WORD) -> DWORD;
pub fn GetActiveProcessorGroupCount() -> WORD;
pub fn GetAppContainerAce(
Acl: PACL, StartingAceIndex: DWORD, AppContainerAce: *mut PVOID,
AppContainerAceIndex: *mut DWORD,
) -> BOOL;
pub fn GetAppContainerNamedObjectPath(
Token: HANDLE, AppContainerSid: PSID, ObjectPathLength: ULONG, ObjectPath: LPWSTR,
ReturnLength: PULONG,
) -> BOOL;
pub fn GetApplicationRecoveryCallback(
hProcess: HANDLE, pRecoveryCallback: *mut APPLICATION_RECOVERY_CALLBACK,
ppvParameter: *mut PVOID, pdwPingInterval: PDWORD, pdwFlags: PDWORD,
) -> HRESULT;
pub fn GetApplicationRestartSettings(
hProcess: HANDLE, pwzCommandline: PWSTR, pcchSize: PDWORD, pdwFlags: PDWORD,
) -> HRESULT;
pub fn GetAtomNameA(nAtom: ATOM, lpBuffer: LPSTR, nSize: c_int) -> UINT;
pub fn GetAtomNameW(nAtom: ATOM, lpBuffer: LPWSTR, nSize: c_int) -> UINT;
pub fn GetBinaryTypeA(lpApplicationName: LPCSTR, lpBinaryType: LPDWORD) -> BOOL;
pub fn GetBinaryTypeW(lpApplicationName: LPCWSTR, lpBinaryType: LPDWORD) -> BOOL;
pub fn GetCPInfo(CodePage: UINT, lpCPInfo: LPCPINFO) -> BOOL;
pub fn GetCPInfoExA(CodePage: UINT, dwFlags: DWORD, lpCPInfoEx: LPCPINFOEXA) -> BOOL;
pub fn GetCPInfoExW(CodePage: UINT, dwFlags: DWORD, lpCPInfoEx: LPCPINFOEXW) -> BOOL;
pub fn GetCachedSigningLevel(
File: HANDLE, Flags: PULONG, SigningLevel: PULONG, Thumbprint: PUCHAR,
ThumbprintSize: PULONG, ThumbprintAlgorithm: PULONG,
) -> BOOL;
pub fn GetCalendarInfoA(
Locale: LCID, Calendar: CALID, CalType: CALTYPE, lpCalData: LPSTR, cchData: c_int,
lpValue: LPDWORD,
) -> c_int;
pub fn GetCalendarInfoEx(
lpLocaleName: LPCWSTR, Calendar: CALID, lpReserved: LPCWSTR, CalType: CALTYPE,
lpCalData: LPWSTR, cchData: c_int, lpValue: LPDWORD,
) -> c_int;
pub fn GetCalendarInfoW(
Locale: LCID, Calendar: CALID, CalType: CALTYPE, lpCalData: LPWSTR, cchData: c_int,
lpValue: LPDWORD,
) -> c_int;
pub fn GetCommConfig(hCommDev: HANDLE, lpCC: LPCOMMCONFIG, lpdwSize: LPDWORD) -> BOOL;
pub fn GetCommMask(hFile: HANDLE, lpEvtMask: LPDWORD) -> BOOL;
pub fn GetCommModemStatus(hFile: HANDLE, lpModemStat: LPDWORD) -> BOOL;
pub fn GetCommProperties(hFile: HANDLE, lpCommProp: LPCOMMPROP) -> BOOL;
pub fn GetCommState(hFile: HANDLE, lpDCB: LPDCB) -> BOOL;
pub fn GetCommTimeouts(hFile: HANDLE, lpCommTimeouts: LPCOMMTIMEOUTS) -> BOOL;
pub fn GetCommandLineA() -> LPSTR;
pub fn GetCommandLineW() -> LPWSTR;
pub fn GetCompressedFileSizeA(lpFileName: LPCSTR, lpFileSizeHigh: LPDWORD) -> DWORD;
pub fn GetCompressedFileSizeTransactedA(
lpFileName: LPCSTR, lpFileSizeHigh: LPDWORD, hTransaction: HANDLE,
) -> DWORD;
pub fn GetCompressedFileSizeTransactedW(
lpFileName: LPCWSTR, lpFileSizeHigh: LPDWORD, hTransaction: HANDLE,
);
pub fn GetCompressedFileSizeW(lpFileName: LPCWSTR, lpFileSizeHigh: LPDWORD) -> DWORD;
pub fn GetComputerNameA(lpBuffer: LPSTR, nSize: LPDWORD) -> BOOL;
pub fn GetComputerNameExA(
NameType: COMPUTER_NAME_FORMAT, lpBuffer: LPSTR, nSize: LPDWORD,
) -> BOOL;
pub fn GetComputerNameExW(
NameType: COMPUTER_NAME_FORMAT, lpBuffer: LPWSTR, nSize: LPDWORD,
) -> BOOL;
pub fn GetComputerNameW(lpBuffer: LPWSTR, nSize: LPDWORD) -> BOOL;
pub fn GetConsoleAliasA(
Source: LPSTR, TargetBuffer: LPSTR, TargetBufferLength: DWORD, ExeName: LPSTR,
) -> DWORD;
pub fn GetConsoleAliasExesA(ExeNameBuffer: LPSTR, ExeNameBufferLength: DWORD) -> DWORD;
pub fn GetConsoleAliasExesLengthA() -> DWORD;
pub fn GetConsoleAliasExesLengthW() -> DWORD;
pub fn GetConsoleAliasExesW(ExeNameBuffer: LPWSTR, ExeNameBufferLength: DWORD) -> DWORD;
pub fn GetConsoleAliasW(
Source: LPWSTR, TargetBuffer: LPWSTR, TargetBufferLength: DWORD, ExeName: LPWSTR,
) -> DWORD;
pub fn GetConsoleAliasesA(
AliasBuffer: LPSTR, AliasBufferLength: DWORD, ExeName: LPSTR,
) -> DWORD;
pub fn GetConsoleAliasesLengthA(ExeName: LPSTR) -> DWORD;
pub fn GetConsoleAliasesLengthW(ExeName: LPWSTR) -> DWORD;
pub fn GetConsoleAliasesW(
AliasBuffer: LPWSTR, AliasBufferLength: DWORD, ExeName: LPWSTR,
) -> DWORD;
pub fn GetConsoleCP() -> UINT;
pub fn GetConsoleCursorInfo(
hConsoleOutput: HANDLE, lpConsoleCursorInfo: PCONSOLE_CURSOR_INFO,
) -> BOOL;
pub fn GetConsoleDisplayMode(lpModeFlags: LPDWORD) -> BOOL;
pub fn GetConsoleFontSize(hConsoleOutput: HANDLE, nFont: DWORD) -> COORD;
pub fn GetConsoleHistoryInfo(lpConsoleHistoryInfo: PCONSOLE_HISTORY_INFO) -> BOOL;
pub fn GetConsoleMode(hConsoleHandle: HANDLE, lpMode: LPDWORD) -> BOOL;
pub fn GetConsoleOriginalTitleA(lpConsoleTitle: LPSTR, nSize: DWORD) -> DWORD;
pub fn GetConsoleOriginalTitleW(lpConsoleTitle: LPWSTR, nSize: DWORD) -> DWORD;
pub fn GetConsoleOutputCP() -> UINT;
pub fn GetConsoleProcessList(lpdwProcessList: LPDWORD, dwProcessCount: DWORD) -> DWORD;
pub fn GetConsoleScreenBufferInfo(
hConsoleOutput: HANDLE, lpConsoleScreenBufferInfo: PCONSOLE_SCREEN_BUFFER_INFO,
) -> BOOL;
pub fn GetConsoleScreenBufferInfoEx(
hConsoleOutput: HANDLE, lpConsoleScreenBufferInfoEx: PCONSOLE_SCREEN_BUFFER_INFOEX,
) -> BOOL;
pub fn GetConsoleSelectionInfo(lpConsoleSelectionInfo: PCONSOLE_SELECTION_INFO) -> BOOL;
pub fn GetConsoleTitleA(lpConsoleTitle: LPSTR, nSize: DWORD) -> DWORD;
pub fn GetConsoleTitleW(lpConsoleTitle: LPWSTR, nSize: DWORD) -> DWORD;
pub fn GetConsoleWindow() -> HWND;
pub fn GetCurrencyFormatA(
Locale: LCID, dwFlags: DWORD, lpValue: LPCSTR, lpFormat: *const CURRENCYFMTA,
lpCurrencyStr: LPSTR, cchCurrency: c_int,
) -> c_int;
pub fn GetCurrencyFormatEx(
lpLocaleName: LPCWSTR, dwFlags: DWORD, lpValue: LPCWSTR, lpFormat: *const CURRENCYFMTW,
lpCurrencyStr: LPWSTR, cchCurrency: c_int,
) -> c_int;
pub fn GetCurrencyFormatW(
Locale: LCID, dwFlags: DWORD, lpValue: LPCWSTR, lpFormat: *const CURRENCYFMTW,
lpCurrencyStr: LPWSTR, cchCurrency: c_int,
) -> c_int;
pub fn GetCurrentActCtx(lphActCtx: *mut HANDLE) -> BOOL;
pub fn GetCurrentConsoleFont(
hConsoleOutput: HANDLE, bMaximumWindow: BOOL, lpConsoleCurrentFont: PCONSOLE_FONT_INFO,
) -> BOOL;
pub fn GetCurrentConsoleFontEx(
hConsoleOutput: HANDLE, bMaximumWindow: BOOL, lpConsoleCurrentFontEx: PCONSOLE_FONT_INFOEX,
) -> BOOL;
pub fn GetCurrentDirectoryA(nBufferLength: DWORD, lpBuffer: LPSTR) -> DWORD;
pub fn GetCurrentDirectoryW(nBufferLength: DWORD, lpBuffer: LPWSTR) -> DWORD;
pub fn GetCurrentProcess() -> HANDLE;
pub fn GetCurrentProcessId() -> DWORD;
pub fn GetCurrentProcessorNumber() -> DWORD;
pub fn GetCurrentProcessorNumberEx(ProcNumber: PPROCESSOR_NUMBER);
pub fn GetCurrentThread() -> HANDLE;
pub fn GetCurrentThreadId() -> DWORD;
pub fn GetCurrentThreadStackLimits(LowLimit: PULONG_PTR, HighLimit: PULONG_PTR);
#[cfg(target_arch = "x86_64")]
pub fn GetCurrentUmsThread() -> PUMS_CONTEXT;
pub fn GetDateFormatA(
Locale: LCID, dwFlags: DWORD, lpDate: *const SYSTEMTIME, lpFormat: LPCSTR, lpDateStr: LPSTR,
cchDate: c_int,
) -> c_int;
pub fn GetDateFormatEx(
lpLocaleName: LPCWSTR, dwFlags: DWORD, lpDate: *const SYSTEMTIME, lpFormat: LPCWSTR,
lpDateStr: LPWSTR, cchDate: c_int, lpCalendar: LPCWSTR,
) -> c_int;
pub fn GetDateFormatW(
Locale: LCID, dwFlags: DWORD, lpDate: *const SYSTEMTIME, lpFormat: LPCWSTR,
lpDateStr: LPWSTR, cchDate: c_int,
) -> c_int;
pub fn GetDefaultCommConfigA(lpszName: LPCSTR, lpCC: LPCOMMCONFIG, lpdwSize: LPDWORD) -> BOOL;
pub fn GetDefaultCommConfigW(lpszName: LPCWSTR, lpCC: LPCOMMCONFIG, lpdwSize: LPDWORD) -> BOOL;
pub fn GetDevicePowerState(hDevice: HANDLE, pfOn: *mut BOOL) -> BOOL;
pub fn GetDiskFreeSpaceA(
lpRootPathName: LPCSTR, lpSectorsPerCluster: LPDWORD, lpBytesPerSector: LPDWORD,
lpNumberOfFreeClusters: LPDWORD, lpTotalNumberOfClusters: LPDWORD,
) -> BOOL;
pub fn GetDiskFreeSpaceExA(
lpDirectoryName: LPCSTR, lpFreeBytesAvailableToCaller: PULARGE_INTEGER,
lpTotalNumberOfBytes: PULARGE_INTEGER, lpTotalNumberOfFreeBytes: PULARGE_INTEGER,
) -> BOOL;
pub fn GetDiskFreeSpaceExW(
lpDirectoryName: LPCWSTR, lpFreeBytesAvailableToCaller: PULARGE_INTEGER,
lpTotalNumberOfBytes: PULARGE_INTEGER, lpTotalNumberOfFreeBytes: PULARGE_INTEGER,
) -> BOOL;
pub fn GetDiskFreeSpaceW(
lpRootPathName: LPCWSTR, lpSectorsPerCluster: LPDWORD, lpBytesPerSector: LPDWORD,
lpNumberOfFreeClusters: LPDWORD, lpTotalNumberOfClusters: LPDWORD,
) -> BOOL;
pub fn GetDllDirectoryA(nBufferLength: DWORD, lpBuffer: LPSTR) -> DWORD;
pub fn GetDllDirectoryW(nBufferLength: DWORD, lpBuffer: LPWSTR) -> DWORD;
pub fn GetDriveTypeA(lpRootPathName: LPCSTR) -> UINT;
pub fn GetDriveTypeW(lpRootPathName: LPCWSTR) -> UINT;
pub fn GetDurationFormat(
Locale: LCID, dwFlags: DWORD, lpDuration: *const SYSTEMTIME, ullDuration: ULONGLONG,
lpFormat: LPCWSTR, lpDurationStr: LPWSTR, cchDuration: c_int,
) -> c_int;
pub fn GetDurationFormatEx(
lpLocaleName: LPCWSTR, dwFlags: DWORD, lpDuration: *const SYSTEMTIME,
ullDuration: ULONGLONG, lpFormat: LPCWSTR, lpDurationStr: LPWSTR, cchDuration: c_int,
) -> c_int;
pub fn GetDynamicTimeZoneInformation(
pTimeZoneInformation: PDYNAMIC_TIME_ZONE_INFORMATION,
) -> DWORD;
#[cfg(any(target_arch = "x86", target_arch = "x86_64"))]
pub fn GetEnabledXStateFeatures() -> DWORD64;
pub fn GetEnvironmentStrings() -> LPCH;
pub fn GetEnvironmentStringsW() -> LPWCH;
pub fn GetEnvironmentVariableA(lpName: LPCSTR, lpBuffer: LPSTR, nSize: DWORD) -> DWORD;
pub fn GetEnvironmentVariableW(lpName: LPCWSTR, lpBuffer: LPWSTR, nSize: DWORD) -> DWORD;
pub fn GetErrorMode() -> UINT;
pub fn GetExitCodeProcess(hProcess: HANDLE, lpExitCode: LPDWORD) -> BOOL;
pub fn GetExitCodeThread(hThread: HANDLE, lpExitCode: LPDWORD) -> BOOL;
pub fn GetFileAttributesA(lpFileName: LPCSTR) -> DWORD;
pub fn GetFileAttributesExA(
lpFileName: LPCSTR, fInfoLevelId: GET_FILEEX_INFO_LEVELS, lpFileInformation: LPVOID,
) -> BOOL;
pub fn GetFileAttributesExW(
lpFileName: LPCWSTR, fInfoLevelId: GET_FILEEX_INFO_LEVELS, lpFileInformation: LPVOID,
) -> BOOL;
pub fn GetFileAttributesTransactedA(
lpFileName: LPCSTR, fInfoLevelId: GET_FILEEX_INFO_LEVELS, lpFileInformation: LPVOID,
hTransaction: HANDLE,
) -> BOOL;
pub fn GetFileAttributesTransactedW(
lpFileName: LPCWSTR, fInfoLevelId: GET_FILEEX_INFO_LEVELS, lpFileInformation: LPVOID,
hTransaction: HANDLE,
) -> BOOL;
pub fn GetFileAttributesW(lpFileName: LPCWSTR) -> DWORD;
pub fn GetFileBandwidthReservation(
hFile: HANDLE, lpPeriodMilliseconds: LPDWORD, lpBytesPerPeriod: LPDWORD,
pDiscardable: LPBOOL, lpTransferSize: LPDWORD, lpNumOutstandingRequests: LPDWORD,
) -> BOOL;
pub fn GetFileInformationByHandle(
hFile: HANDLE, lpFileInformation: LPBY_HANDLE_FILE_INFORMATION,
) -> BOOL;
pub fn GetFileInformationByHandleEx(
hFile: HANDLE, FileInformationClass: FILE_INFO_BY_HANDLE_CLASS, lpFileInformation: LPVOID,
dwBufferSize: DWORD,
) -> BOOL;
pub fn GetFileMUIInfo(
dwFlags: DWORD, pcwszFilePath: PCWSTR, pFileMUIInfo: PFILEMUIINFO,
pcbFileMUIInfo: *mut DWORD,
) -> BOOL;
pub fn GetFileMUIPath(
dwFlags: DWORD, pcwszFilePath: PCWSTR, pwszLanguage: PWSTR, pcchLanguage: PULONG,
pwszFileMUIPath: PWSTR, pcchFileMUIPath: PULONG, pululEnumerator: ULONGLONG,
) -> BOOL;
pub fn GetFileSize(hFile: HANDLE, lpFileSizeHigh: LPDWORD) -> DWORD;
pub fn GetFileSizeEx(hFile: HANDLE, lpFileSize: PLARGE_INTEGER) -> BOOL;
pub fn GetFileTime(
hFile: HANDLE, lpCreationTime: LPFILETIME, lpLastAccessTime: LPFILETIME,
lpLastWriteTime: LPFILETIME,
) -> BOOL;
pub fn GetFileType(hFile: HANDLE) -> DWORD;
pub fn GetFinalPathNameByHandleA(
hFile: HANDLE, lpszFilePath: LPSTR, cchFilePath: DWORD, dwFlags: DWORD,
) -> DWORD;
pub fn GetFinalPathNameByHandleW(
hFile: HANDLE, lpszFilePath: LPWSTR, cchFilePath: DWORD, dwFlags: DWORD,
) -> DWORD;
pub fn GetFirmwareEnvironmentVariableA(
lpName: LPCSTR, lpGuid: LPCSTR, pBuffer: PVOID, nSize: DWORD,
) -> DWORD;
pub fn GetFirmwareEnvironmentVariableExA(
lpName: LPCSTR, lpGuid: LPCSTR, pBuffer: PVOID, nSize: DWORD, pdwAttribubutes: PDWORD,
) -> DWORD;
pub fn GetFirmwareEnvironmentVariableExW(
lpName: LPCWSTR, lpGuid: LPCWSTR, pBuffer: PVOID, nSize: DWORD, pdwAttribubutes: PDWORD,
) -> DWORD;
pub fn GetFirmwareEnvironmentVariableW(
lpName: LPCWSTR, lpGuid: LPCWSTR, pBuffer: PVOID, nSize: DWORD,
) -> DWORD;
pub fn GetFirmwareType(FirmwareType: PFIRMWARE_TYPE) -> BOOL;
pub fn GetFullPathNameA(
lpFileName: LPCSTR, nBufferLength: DWORD, lpBuffer: LPSTR, lpFilePart: *mut LPSTR,
) -> DWORD;
pub fn GetFullPathNameTransactedA(
lpFileName: LPCSTR, nBufferLength: DWORD, lpBuffer: LPSTR, lpFilePart: *mut LPSTR,
hTransaction: HANDLE,
) -> DWORD;
pub fn GetFullPathNameTransactedW(
lpFileName: LPCWSTR, nBufferLength: DWORD, lpBuffer: LPWSTR, lpFilePart: *mut LPWSTR,
hTransaction: HANDLE,
);
pub fn GetFullPathNameW(
lpFileName: LPCWSTR, nBufferLength: DWORD, lpBuffer: LPWSTR, lpFilePart: *mut LPWSTR,
) -> DWORD;
pub fn GetGeoInfoA(
Location: GEOID, GeoType: GEOTYPE, lpGeoData: LPSTR, cchData: c_int, LangId: LANGID,
) -> c_int;
pub fn GetGeoInfoW(
Location: GEOID, GeoType: GEOTYPE, lpGeoData: LPWSTR, cchData: c_int, LangId: LANGID,
) -> c_int;
pub fn GetHandleInformation(hObject: HANDLE, lpdwFlags: LPDWORD) -> BOOL;
pub fn GetLargePageMinimum() -> SIZE_T;
pub fn GetLargestConsoleWindowSize(hConsoleOutput: HANDLE) -> COORD;
pub fn GetLastError() -> DWORD;
pub fn GetLocalTime(lpSystemTime: LPSYSTEMTIME);
pub fn GetLocaleInfoA(
Locale: LCID, LCType: LCTYPE, lpLCData: LPSTR, cchData: c_int,
) -> c_int;
pub fn GetLocaleInfoEx(
lpLocaleName: LPCWSTR, LCType: LCTYPE, lpLCData: LPWSTR, cchData: c_int,
) -> c_int;
pub fn GetLocaleInfoW(
Locale: LCID, LCType: LCTYPE, lpLCData: LPWSTR, cchData: c_int,
) -> c_int;
pub fn GetLogicalDriveStringsA(nBufferLength: DWORD, lpBuffer: LPSTR) -> DWORD;
pub fn GetLogicalDriveStringsW(nBufferLength: DWORD, lpBuffer: LPWSTR) -> DWORD;
pub fn GetLogicalDrives() -> DWORD;
pub fn GetLogicalProcessorInformation(
Buffer: PSYSTEM_LOGICAL_PROCESSOR_INFORMATION, ReturnedLength: PDWORD,
) -> BOOL;
pub fn GetLogicalProcessorInformationEx(
RelationshipType: LOGICAL_PROCESSOR_RELATIONSHIP,
Buffer: PSYSTEM_LOGICAL_PROCESSOR_INFORMATION,
ReturnedLength: PDWORD,
) -> BOOL;
pub fn GetLongPathNameA(lpszShortPath: LPCSTR, lpszLongPath: LPSTR, cchBuffer: DWORD) -> DWORD;
pub fn GetLongPathNameTransactedA(
lpszShortPath: LPCSTR, lpszLongPath: LPSTR, cchBuffer: DWORD, hTransaction: HANDLE,
) -> DWORD;
pub fn GetLongPathNameTransactedW(
lpszShortPath: LPCWSTR, lpszLongPath: LPWSTR, cchBuffer: DWORD, hTransaction: HANDLE,
) -> DWORD;
pub fn GetLongPathNameW(
lpszShortPath: LPCWSTR, lpszLongPath: LPWSTR, cchBuffer: DWORD,
) -> DWORD;
pub fn GetMailslotInfo(
hMailslot: HANDLE, lpMaxMessageSize: LPDWORD, lpNextSize: LPDWORD, lpMessageCount: LPDWORD,
lpReadTimeout: LPDWORD,
) -> BOOL;
pub fn GetMaximumProcessorCount(GroupNumber: WORD) -> DWORD;
pub fn GetMaximumProcessorGroupCount() -> WORD;
pub fn GetMemoryErrorHandlingCapabilities(Capabilities: PULONG) -> BOOL;
pub fn GetModuleFileNameA(
hModule: HMODULE, lpFilename: LPSTR, nSize: DWORD,
) -> DWORD;
pub fn GetModuleFileNameW(
hModule: HMODULE, lpFilename: LPWSTR, nSize: DWORD,
) -> DWORD;
pub fn GetModuleHandleA(lpModuleName: LPCSTR) -> HMODULE;
pub fn GetModuleHandleExA(
dwFlags: DWORD, lpModuleName: LPCSTR, phModule: *mut HMODULE,
) -> BOOL;
pub fn GetModuleHandleExW(
dwFlags: DWORD, lpModuleName: LPCWSTR, phModule: *mut HMODULE,
) -> BOOL;
pub fn GetModuleHandleW(lpModuleName: LPCWSTR) -> HMODULE;
pub fn GetNLSVersion(
Function: NLS_FUNCTION, Locale: LCID, lpVersionInformation: LPNLSVERSIONINFO,
) -> BOOL;
pub fn GetNLSVersionEx(
function: NLS_FUNCTION, lpLocaleName: LPCWSTR, lpVersionInformation: LPNLSVERSIONINFOEX,
) -> BOOL;
pub fn GetNamedPipeClientComputerNameA(
Pipe: HANDLE, ClientComputerName: LPSTR, ClientComputerNameLength: ULONG,
) -> BOOL;
pub fn GetNamedPipeClientComputerNameW(
Pipe: HANDLE, ClientComputerName: LPWSTR, ClientComputerNameLength: ULONG,
) -> BOOL;
pub fn GetNamedPipeClientProcessId(Pipe: HANDLE, ClientProcessId: PULONG) -> BOOL;
pub fn GetNamedPipeClientSessionId(Pipe: HANDLE, ClientSessionId: PULONG) -> BOOL;
pub fn GetNamedPipeHandleStateA(
hNamedPipe: HANDLE, lpState: LPDWORD, lpCurInstances: LPDWORD,
lpMaxCollectionCount: LPDWORD, lpCollectDataTimeout: LPDWORD, lpUserName: LPSTR,
nMaxUserNameSize: DWORD,
) -> BOOL;
pub fn GetNamedPipeHandleStateW(
hNamedPipe: HANDLE, lpState: LPDWORD, lpCurInstances: LPDWORD,
lpMaxCollectionCount: LPDWORD, lpCollectDataTimeout: LPDWORD, lpUserName: LPWSTR,
nMaxUserNameSize: DWORD,
) -> BOOL;
pub fn GetNamedPipeInfo(
hNamedPipe: HANDLE, lpFlags: LPDWORD, lpOutBufferSize: LPDWORD, lpInBufferSize: LPDWORD,
lpMaxInstances: LPDWORD,
) -> BOOL;
pub fn GetNamedPipeServerProcessId(Pipe: HANDLE, ServerProcessId: PULONG) -> BOOL;
pub fn GetNamedPipeServerSessionId(Pipe: HANDLE, ServerSessionId: PULONG) -> BOOL;
pub fn GetNativeSystemInfo(lpSystemInfo: LPSYSTEM_INFO);
#[cfg(target_arch = "x86_64")]
pub fn GetNextUmsListItem(UmsContext: PUMS_CONTEXT) -> PUMS_CONTEXT;
pub fn GetNumaAvailableMemoryNode(Node: UCHAR, AvailableBytes: PULONGLONG) -> BOOL;
pub fn GetNumaAvailableMemoryNodeEx(Node: USHORT, AvailableBytes: PULONGLONG) -> BOOL;
pub fn GetNumaHighestNodeNumber(HighestNodeNumber: PULONG) -> BOOL;
pub fn GetNumaNodeNumberFromHandle(hFile: HANDLE, NodeNumber: PUSHORT) -> BOOL;
pub fn GetNumaNodeProcessorMask(Node: UCHAR, ProcessorMask: PULONGLONG) -> BOOL;
pub fn GetNumaNodeProcessorMaskEx(Node: USHORT, ProcessorMask: PGROUP_AFFINITY) -> BOOL;
pub fn GetNumaProcessorNode(Processor: UCHAR, NodeNumber: PUCHAR) -> BOOL;
pub fn GetNumaProcessorNodeEx(Processor: PPROCESSOR_NUMBER, NodeNumber: PUSHORT) -> BOOL;
pub fn GetNumaProximityNode(ProximityId: ULONG, NodeNumber: PUCHAR) -> BOOL;
pub fn GetNumaProximityNodeEx(ProximityId: ULONG, NodeNumber: PUSHORT) -> BOOL;
pub fn GetNumberFormatA(
Locale: LCID, dwFlags: DWORD, lpValue: LPCSTR, lpFormat: *const NUMBERFMTA,
lpNumberStr: LPSTR, cchNumber: c_int,
) -> c_int;
pub fn GetNumberFormatEx(
lpLocaleName: LPCWSTR, dwFlags: DWORD, lpValue: LPCWSTR, lpFormat: *const NUMBERFMTW,
lpNumberStr: LPWSTR, cchNumber: c_int,
) -> c_int;
pub fn GetNumberFormatW(
Locale: LCID, dwFlags: DWORD, lpValue: LPCWSTR, lpFormat: *const NUMBERFMTW,
lpNumberStr: LPWSTR, cchNumber: c_int,
) -> c_int;
pub fn GetNumberOfConsoleInputEvents(hConsoleInput: HANDLE, lpNumberOfEvents: LPDWORD) -> BOOL;
pub fn GetNumberOfConsoleMouseButtons(lpNumberOfMouseButtons: LPDWORD) -> BOOL;
pub fn GetOEMCP() -> UINT;
pub fn GetOverlappedResult(
hFile: HANDLE, lpOverlapped: LPOVERLAPPED, lpNumberOfBytesTransferred: LPDWORD, bWait: BOOL,
) -> BOOL;
pub fn GetOverlappedResultEx(
hFile: HANDLE, lpOverlapped: LPOVERLAPPED, lpNumberOfBytesTransferred: LPDWORD,
dwMilliseconds: DWORD, bAlertable: BOOL,
) -> BOOL;
pub fn GetPhysicallyInstalledSystemMemory(TotalMemoryInKilobytes: PULONGLONG) -> BOOL;
pub fn GetPriorityClass(hProcess: HANDLE) -> DWORD;
pub fn GetPrivateProfileIntA(
lpAppName: LPCSTR, lpKeyName: LPCSTR, nDefault: INT, lpFileName: LPCSTR,
) -> UINT;
pub fn GetPrivateProfileIntW(
lpAppName: LPCWSTR, lpKeyName: LPCWSTR, nDefault: INT, lpFileName: LPCWSTR,
) -> UINT;
pub fn GetPrivateProfileSectionA(
lpAppName: LPCSTR, lpReturnedString: LPSTR, nSize: DWORD, lpFileName: LPCSTR,
) -> DWORD;
pub fn GetPrivateProfileSectionNamesA(
lpszReturnBuffer: LPSTR, nSize: DWORD, lpFileName: LPCSTR,
) -> DWORD;
pub fn GetPrivateProfileSectionNamesW(
lpszReturnBuffer: LPWSTR, nSize: DWORD, lpFileName: LPCWSTR,
) -> DWORD;
pub fn GetPrivateProfileSectionW(
lpAppName: LPCWSTR, lpReturnedString: LPWSTR, nSize: DWORD, lpFileName: LPCWSTR,
) -> DWORD;
pub fn GetPrivateProfileStringA(
lpAppName: LPCSTR, lpKeyName: LPCSTR, lpDefault: LPCSTR, lpReturnedString: LPSTR,
nSize: DWORD, lpFileName: LPCSTR,
) -> DWORD;
pub fn GetPrivateProfileStringW(
lpAppName: LPCWSTR, lpKeyName: LPCWSTR, lpDefault: LPCWSTR, lpReturnedString: LPWSTR,
nSize: DWORD, lpFileName: LPCWSTR,
) -> DWORD;
pub fn GetPrivateProfileStructA(
lpszSection: LPCSTR, lpszKey: LPCSTR, lpStruct: LPVOID, uSizeStruct: UINT, szFile: LPCSTR,
) -> BOOL;
pub fn GetPrivateProfileStructW(
lpszSection: LPCWSTR, lpszKey: LPCWSTR, lpStruct: LPVOID, uSizeStruct: UINT,
szFile: LPCWSTR,
) -> BOOL;
pub fn GetProcAddress(hModule: HMODULE, lpProcName: LPCSTR) -> FARPROC;
pub fn GetProcessAffinityMask(
hProcess: HANDLE, lpProcessAffinityMask: PDWORD_PTR, lpSystemAffinityMask: PDWORD_PTR,
) -> BOOL;
pub fn GetProcessDEPPolicy(hProcess: HANDLE, lpFlags: LPDWORD, lpPermanent: PBOOL) -> BOOL;
pub fn GetProcessGroupAffinity(
hProcess: HANDLE, GroupCount: PUSHORT, GroupArray: PUSHORT,
) -> BOOL;
pub fn GetProcessHandleCount(hProcess: HANDLE, pdwHandleCount: PDWORD) -> BOOL;
pub fn GetProcessHeap() -> HANDLE;
pub fn GetProcessHeaps(NumberOfHeaps: DWORD, ProcessHeaps: PHANDLE) -> DWORD;
pub fn GetProcessId(Process: HANDLE) -> DWORD;
pub fn GetProcessIdOfThread(Thread: HANDLE) -> DWORD;
pub fn GetProcessInformation(
hProcess: HANDLE, ProcessInformationClass: PROCESS_INFORMATION_CLASS,
ProcessInformation: LPVOID, ProcessInformationSize: DWORD,
) -> BOOL;
pub fn GetProcessIoCounters(hProcess: HANDLE, lpIoCounters: PIO_COUNTERS) -> BOOL;
pub fn GetProcessMitigationPolicy(
hProcess: HANDLE, MitigationPolicy: PROCESS_MITIGATION_POLICY, lpBuffer: LPVOID,
dwLength: SIZE_T,
) -> BOOL;
pub fn GetProcessPreferredUILanguages(
dwFlags: DWORD, pulNumLanguages: PULONG, pwszLanguagesBuffer: PZZWSTR,
pcchLanguagesBuffer: PULONG,
) -> BOOL;
pub fn GetProcessPriorityBoost(hProcess: HANDLE, pDisablePriorityBoost: PBOOL) -> BOOL;
pub fn GetProcessShutdownParameters(lpdwLevel: LPDWORD, lpdwFlags: LPDWORD) -> BOOL;
pub fn GetProcessTimes(
hProcess: HANDLE, lpCreationTime: LPFILETIME, lpExitTime: LPFILETIME,
lpKernelTime: LPFILETIME, lpUserTime: LPFILETIME,
) -> BOOL;
pub fn GetProcessVersion(ProcessId: DWORD) -> DWORD;
pub fn GetProcessWorkingSetSize(
hProcess: HANDLE, lpMinimumWorkingSetSize: PSIZE_T, lpMaximumWorkingSetSize: PSIZE_T,
) -> BOOL;
pub fn GetProcessWorkingSetSizeEx(
hProcess: HANDLE, lpMinimumWorkingSetSize: PSIZE_T, lpMaximumWorkingSetSize: PSIZE_T,
Flags: PDWORD,
) -> BOOL;
pub fn GetProcessorSystemCycleTime(
Group: USHORT, Buffer: PSYSTEM_PROCESSOR_CYCLE_TIME_INFORMATION, ReturnedLength: PDWORD,
) -> BOOL;
pub fn GetProductInfo(
dwOSMajorVersion: DWORD, dwOSMinorVersion: DWORD, dwSpMajorVersion: DWORD,
dwSpMinorVersion: DWORD, pdwReturnedProductType: PDWORD,
) -> BOOL;
pub fn GetProfileIntA(lpAppName: LPCSTR, lpKeyName: LPCSTR, nDefault: INT) -> UINT;
pub fn GetProfileIntW(lpAppName: LPCWSTR, lpKeyName: LPCWSTR, nDefault: INT) -> UINT;
pub fn GetProfileSectionA(lpAppName: LPCSTR, lpReturnedString: LPSTR, nSize: DWORD) -> DWORD;
pub fn GetProfileSectionW(lpAppName: LPCWSTR, lpReturnedString: LPWSTR, nSize: DWORD) -> DWORD;
pub fn GetProfileStringA(
lpAppName: LPCSTR, lpKeyName: LPCSTR, lpDefault: LPCSTR, lpReturnedString: LPSTR,
nSize: DWORD,
) -> DWORD;
pub fn GetProfileStringW(
lpAppName: LPCWSTR, lpKeyName: LPCWSTR, lpDefault: LPCWSTR, lpReturnedString: LPWSTR,
nSize: DWORD,
) -> DWORD;
pub fn GetQueuedCompletionStatus(
CompletionPort: HANDLE, lpNumberOfBytesTransferred: LPDWORD, lpCompletionKey: PULONG_PTR,
lpOverlapped: *mut LPOVERLAPPED, dwMilliseconds: DWORD,
) -> BOOL;
pub fn GetQueuedCompletionStatusEx(
CompletionPort: HANDLE, lpCompletionPortEntries: LPOVERLAPPED_ENTRY, ulCount: ULONG,
ulNumEntriesRemoved: PULONG, dwMilliseconds: DWORD, fAlertable: BOOL,
) -> BOOL;
pub fn GetShortPathNameA(
lpszLongPath: LPCSTR, lpszShortPath: LPSTR, cchBuffer: DWORD,
) -> DWORD;
pub fn GetShortPathNameW(
lpszLongPath: LPCWSTR, lpszShortPath: LPWSTR, cchBuffer: DWORD,
) -> DWORD;
pub fn GetStartupInfoA(lpStartupInfo: LPSTARTUPINFOA);
pub fn GetStartupInfoW(lpStartupInfo: LPSTARTUPINFOW);
pub fn GetStdHandle(nStdHandle: DWORD) -> HANDLE;
pub fn GetStringScripts(
dwFlags: DWORD, lpString: LPCWSTR, cchString: c_int, lpScripts: LPWSTR, cchScripts: c_int,
) -> c_int;
pub fn GetStringTypeA(
Locale: LCID, dwInfoType: DWORD, lpSrcStr: LPCSTR, cchSrc: c_int, lpCharType: LPWORD,
) -> BOOL;
pub fn GetStringTypeExA(
Locale: LCID, dwInfoType: DWORD, lpSrcStr: LPCSTR, cchSrc: c_int, lpCharType: LPWORD,
) -> BOOL;
pub fn GetStringTypeExW(
Locale: LCID, dwInfoType: DWORD, lpSrcStr: LPCWCH, cchSrc: c_int, lpCharType: LPWORD,
) -> BOOL;
pub fn GetStringTypeW(
dwInfoType: DWORD, lpSrcStr: LPCWCH, cchSrc: c_int, lpCharType: LPWORD,
) -> BOOL;
pub fn GetSystemDEPPolicy() -> DEP_SYSTEM_POLICY_TYPE;
pub fn GetSystemDefaultLCID() -> LCID;
pub fn GetSystemDefaultLangID() -> LANGID;
pub fn GetSystemDefaultLocaleName(lpLocaleName: LPWSTR, cchLocaleName: c_int) -> c_int;
pub fn GetSystemDefaultUILanguage() -> LANGID;
pub fn GetSystemDirectoryA(lpBuffer: LPSTR, uSize: UINT) -> UINT;
pub fn GetSystemDirectoryW(lpBuffer: LPWSTR, uSize: UINT) -> UINT;
pub fn GetSystemFileCacheSize(
lpMinimumFileCacheSize: PSIZE_T, lpMaximumFileCacheSize: PSIZE_T, lpFlags: PDWORD,
) -> BOOL;
pub fn GetSystemFirmwareTable(
FirmwareTableProviderSignature: DWORD, FirmwareTableID: DWORD, pFirmwareTableBuffer: PVOID,
BufferSize: DWORD,
) -> UINT;
pub fn GetSystemInfo(lpSystemInfo: LPSYSTEM_INFO);
pub fn GetSystemPowerStatus(lpSystemPowerStatus: LPSYSTEM_POWER_STATUS) -> BOOL;
pub fn GetSystemPreferredUILanguages(
dwFlags: DWORD, pulNumLanguages: PULONG, pwszLanguagesBuffer: PZZWSTR,
pcchLanguagesBuffer: PULONG,
) -> BOOL;
pub fn GetSystemRegistryQuota(pdwQuotaAllowed: PDWORD, pdwQuotaUsed: PDWORD) -> BOOL;
pub fn GetSystemTime(lpSystemTime: LPSYSTEMTIME);
pub fn GetSystemTimeAdjustment(
lpTimeAdjustment: PDWORD, lpTimeIncrement: PDWORD, lpTimeAdjustmentDisabled: PBOOL,
) -> BOOL;
pub fn GetSystemTimeAsFileTime(lpSystemTimeAsFileTime: LPFILETIME);
pub fn GetSystemTimePreciseAsFileTime(lpSystemTimeAsFileTime: LPFILETIME);
pub fn GetSystemTimes(
lpIdleTime: PFILETIME, lpKernelTime: PFILETIME, lpUserTime: PFILETIME,
) -> BOOL;
pub fn GetSystemWindowsDirectoryA(lpBuffer: LPSTR, uSize: UINT) -> UINT;
pub fn GetSystemWindowsDirectoryW(lpBuffer: LPWSTR, uSize: UINT) -> UINT;
pub fn GetSystemWow64DirectoryA(lpBuffer: LPSTR, uSize: UINT) -> UINT;
pub fn GetSystemWow64DirectoryW(lpBuffer: LPWSTR, uSize: UINT) -> UINT;
pub fn GetTapeParameters(
hDevice: HANDLE, dwOperation: DWORD, lpdwSize: LPDWORD, lpTapeInformation: LPVOID
) -> DWORD;
pub fn GetTapePosition(
hDevice: HANDLE, dwPositionType: DWORD, lpdwPartition: LPDWORD,
lpdwOffsetLow: LPDWORD, lpdwOffsetHigh: LPDWORD
) -> DWORD;
pub fn GetTapeStatus(hDevice: HANDLE) -> DWORD;
pub fn GetTempFileNameA(
lpPathName: LPCSTR, lpPrefixString: LPCSTR, uUnique: UINT, lpTempFileName: LPSTR,
) -> UINT;
pub fn GetTempFileNameW(
lpPathName: LPCWSTR, lpPrefixString: LPCWSTR, uUnique: UINT, lpTempFileName: LPWSTR,
) -> UINT;
pub fn GetTempPathA(nBufferLength: DWORD, lpBuffer: LPSTR) -> DWORD;
pub fn GetTempPathW(nBufferLength: DWORD, lpBuffer: LPWSTR) -> DWORD;
pub fn GetThreadContext(hThread: HANDLE, lpContext: LPCONTEXT) -> BOOL;
pub fn GetThreadErrorMode() -> DWORD;
pub fn GetThreadGroupAffinity(hThread: HANDLE, GroupAffinity: PGROUP_AFFINITY) -> BOOL;
pub fn GetThreadIOPendingFlag(hThread: HANDLE, lpIOIsPending: PBOOL) -> BOOL;
pub fn GetThreadId(Thread: HANDLE) -> DWORD;
pub fn GetThreadIdealProcessorEx(hThread: HANDLE, lpIdealProcessor: PPROCESSOR_NUMBER) -> BOOL;
pub fn GetThreadInformation(
hThread: HANDLE, ThreadInformationClass: THREAD_INFORMATION_CLASS,
ThreadInformation: LPVOID, ThreadInformationSize: DWORD,
) -> BOOL;
pub fn GetThreadLocale() -> LCID;
pub fn GetThreadPreferredUILanguages(
dwFlags: DWORD, pulNumLanguages: PULONG, pwszLanguagesBuffer: PZZWSTR,
pcchLanguagesBuffer: PULONG,
) -> BOOL;
pub fn GetThreadPriority(hThread: HANDLE) -> c_int;
pub fn GetThreadPriorityBoost(hThread: HANDLE, pDisablePriorityBoost: PBOOL) -> BOOL;
pub fn GetThreadSelectorEntry(
hThread: HANDLE, dwSelector: DWORD, lpSelectorEntry: LPLDT_ENTRY,
) -> BOOL;
pub fn GetThreadTimes(
hThread: HANDLE, lpCreationTime: LPFILETIME, lpExitTime: LPFILETIME,
lpKernelTime: LPFILETIME, lpUserTime: LPFILETIME,
) -> BOOL;
pub fn GetThreadUILanguage() -> LANGID;
pub fn GetTickCount() -> DWORD;
pub fn GetTickCount64() -> ULONGLONG;
pub fn GetTimeFormatA(
Locale: LCID, dwFlags: DWORD, lpTime: *const SYSTEMTIME, lpFormat: LPCSTR,
lpTimeStr: LPSTR, cchTime: c_int,
) -> c_int;
pub fn GetTimeFormatEx(
lpLocaleName: LPCWSTR, dwFlags: DWORD, lpTime: *const SYSTEMTIME, lpFormat: LPCWSTR,
lpTimeStr: LPWSTR, cchTime: c_int,
) -> c_int;
pub fn GetTimeFormatW(
Locale: LCID, dwFlags: DWORD, lpTime: *const SYSTEMTIME, lpFormat: LPCWSTR,
lpTimeStr: LPWSTR, cchTime: c_int,
) -> c_int;
pub fn GetTimeZoneInformation(lpTimeZoneInformation: LPTIME_ZONE_INFORMATION) -> DWORD;
pub fn GetTimeZoneInformationForYear(
wYear: USHORT, pdtzi: PDYNAMIC_TIME_ZONE_INFORMATION, ptzi: LPTIME_ZONE_INFORMATION,
) -> BOOL;
pub fn GetUILanguageInfo(
dwFlags: DWORD, pwmszLanguage: PCZZWSTR, pwszFallbackLanguages: PZZWSTR,
pcchFallbackLanguages: PDWORD, pAttributes: PDWORD,
) -> BOOL;
#[cfg(target_arch = "x86_64")]
pub fn GetUmsCompletionListEvent(
UmsCompletionList: PUMS_COMPLETION_LIST, UmsCompletionEvent: PHANDLE,
) -> BOOL;
#[cfg(target_arch = "x86_64")]
pub fn GetUmsSystemThreadInformation(
ThreadHandle: HANDLE, SystemThreadInfo: PUMS_SYSTEM_THREAD_INFORMATION,
) -> BOOL;
pub fn GetUserDefaultLCID() -> LCID;
pub fn GetUserDefaultLangID() -> LANGID;
pub fn GetUserDefaultLocaleName(lpLocaleName: LPWSTR, cchLocaleName: c_int) -> c_int;
pub fn GetUserDefaultUILanguage() -> LANGID;
pub fn GetUserGeoID(GeoClass: GEOCLASS) -> GEOID;
pub fn GetUserPreferredUILanguages(
dwFlags: DWORD, pulNumLanguages: PULONG, pwszLanguagesBuffer: PZZWSTR,
pcchLanguagesBuffer: PULONG,
) -> BOOL;
pub fn GetVersion() -> DWORD;
pub fn GetVersionExA(lpVersionInformation: LPOSVERSIONINFOA) -> BOOL;
pub fn GetVersionExW(lpVersionInformation: LPOSVERSIONINFOW) -> BOOL;
pub fn GetVolumeInformationA(
lpRootPathName: LPCSTR, lpVolumeNameBuffer: LPSTR, nVolumeNameSize: DWORD,
lpVolumeSerialNumber: LPDWORD, lpMaximumComponentLength: LPDWORD,
lpFileSystemFlags: LPDWORD, lpFileSystemNameBuffer: LPSTR, nFileSystemNameSize: DWORD,
) -> BOOL;
pub fn GetVolumeInformationByHandleW(
hFile: HANDLE, lpVolumeNameBuffer: LPWSTR, nVolumeNameSize: DWORD,
lpVolumeSerialNumber: LPDWORD, lpMaximumComponentLength: LPDWORD,
lpFileSystemFlags: LPDWORD, lpFileSystemNameBuffer: LPWSTR, nFileSystemNameSize: DWORD,
) -> BOOL;
pub fn GetVolumeInformationW(
lpRootPathName: LPCWSTR, lpVolumeNameBuffer: LPWSTR, nVolumeNameSize: DWORD,
lpVolumeSerialNumber: LPDWORD, lpMaximumComponentLength: LPDWORD,
lpFileSystemFlags: LPDWORD, lpFileSystemNameBuffer: LPWSTR, nFileSystemNameSize: DWORD,
) -> BOOL;
pub fn GetVolumeNameForVolumeMountPointA(
lpszVolumeMountPoint: LPCSTR, lpszVolumeName: LPSTR, cchBufferLength: DWORD,
) -> BOOL;
pub fn GetVolumeNameForVolumeMountPointW(
lpszVolumeMountPoint: LPCWSTR, lpszVolumeName: LPWSTR, cchBufferLength: DWORD,
) -> BOOL;
pub fn GetVolumePathNameA(
lpszFileName: LPCSTR, lpszVolumePathName: LPSTR, cchBufferLength: DWORD,
) -> BOOL;
pub fn GetVolumePathNameW(
lpszFileName: LPCWSTR, lpszVolumePathName: LPWSTR, cchBufferLength: DWORD,
) -> BOOL;
pub fn GetVolumePathNamesForVolumeNameA(
lpszVolumeName: LPCSTR, lpszVolumePathNames: LPCH, cchBufferLength: DWORD,
lpcchReturnLength: PDWORD,
) -> BOOL;
pub fn GetVolumePathNamesForVolumeNameW(
lpszVolumeName: LPCWSTR, lpszVolumePathNames: LPWCH, cchBufferLength: DWORD,
lpcchReturnLength: PDWORD,
) -> BOOL;
pub fn GetWindowsDirectoryA(lpBuffer: LPSTR, uSize: UINT) -> UINT;
pub fn GetWindowsDirectoryW(lpBuffer: LPWSTR, uSize: UINT) -> UINT;
pub fn GetWriteWatch(
dwFlags: DWORD, lpBaseAddress: PVOID, dwRegionSize: SIZE_T, lpAddresses: *mut PVOID,
lpdwCount: *mut ULONG_PTR, lpdwGranularity: LPDWORD,
) -> UINT;
#[cfg(any(target_arch = "x86", target_arch = "x86_64"))]
pub fn GetXStateFeaturesMask(Context: PCONTEXT, FeatureMask: PDWORD64) -> BOOL;
pub fn GlobalAddAtomA(lpString: LPCSTR) -> ATOM;
pub fn GlobalAddAtomExA(lpString: LPCSTR, Flags: DWORD) -> ATOM;
pub fn GlobalAddAtomExW(lpString: LPCWSTR, Flags: DWORD) -> ATOM;
pub fn GlobalAddAtomW(lpString: LPCWSTR) -> ATOM;
pub fn GlobalAlloc(uFlags: UINT, dwBytes: SIZE_T) -> HGLOBAL;
pub fn GlobalCompact(dwMinFree: DWORD) -> SIZE_T;
pub fn GlobalDeleteAtom(nAtom: ATOM) -> ATOM;
pub fn GlobalFindAtomA(lpString: LPCSTR) -> ATOM;
pub fn GlobalFindAtomW(lpString: LPCWSTR) -> ATOM;
pub fn GlobalFix(hMem: HGLOBAL);
pub fn GlobalFlags(hMem: HGLOBAL) -> UINT;
pub fn GlobalFree(hMem: HGLOBAL) -> HGLOBAL;
pub fn GlobalGetAtomNameA(nAtom: ATOM, lpBuffer: LPSTR, nSize: c_int) -> UINT;
pub fn GlobalGetAtomNameW(nAtom: ATOM, lpBuffer: LPWSTR, nSize: c_int) -> UINT;
pub fn GlobalHandle(pMem: LPCVOID) -> HGLOBAL;
pub fn GlobalLock(hMem: HGLOBAL) -> LPVOID;
pub fn GlobalMemoryStatus(lpBuffer: LPMEMORYSTATUS);
pub fn GlobalMemoryStatusEx(lpBuffer: LPMEMORYSTATUSEX) -> BOOL;
pub fn GlobalReAlloc(hMem: HGLOBAL, dwBytes: SIZE_T, uFlags: UINT) -> HGLOBAL;
pub fn GlobalSize(hMem: HGLOBAL) -> SIZE_T;
pub fn GlobalUnWire(hMem: HGLOBAL) -> BOOL;
pub fn GlobalUnfix(hMem: HGLOBAL);
pub fn GlobalUnlock(hMem: HGLOBAL) -> BOOL;
pub fn GlobalWire(hMem: HGLOBAL) -> LPVOID;
pub fn Heap32First(lphe: LPHEAPENTRY32, th32ProcessID: DWORD, th32HeapID: ULONG_PTR) -> BOOL;
pub fn Heap32ListFirst(hSnapshot: HANDLE, lphl: LPHEAPLIST32) -> BOOL;
pub fn Heap32ListNext(hSnapshot: HANDLE, lphl: LPHEAPLIST32) -> BOOL;
pub fn Heap32Next(lphe: LPHEAPENTRY32) -> BOOL;
pub fn HeapAlloc(hHeap: HANDLE, dwFlags: DWORD, dwBytes: SIZE_T) -> LPVOID;
pub fn HeapCompact(hHeap: HANDLE, dwFlags: DWORD) -> SIZE_T;
pub fn HeapCreate(flOptions: DWORD, dwInitialSize: SIZE_T, dwMaximumSize: SIZE_T) -> HANDLE;
pub fn HeapDestroy(hHeap: HANDLE) -> BOOL;
pub fn HeapFree(hHeap: HANDLE, dwFlags: DWORD, lpMem: LPVOID) -> BOOL;
pub fn HeapLock(hHeap: HANDLE) -> BOOL;
pub fn HeapQueryInformation(
HeapHandle: HANDLE, HeapInformationClass: HEAP_INFORMATION_CLASS, HeapInformation: PVOID,
HeapInformationLength: SIZE_T, ReturnLength: PSIZE_T,
) -> BOOL;
pub fn HeapReAlloc(hHeap: HANDLE, dwFlags: DWORD, lpMem: LPVOID, dwBytes: SIZE_T) -> LPVOID;
pub fn HeapSetInformation(
HeapHandle: HANDLE, HeapInformationClass: HEAP_INFORMATION_CLASS, HeapInformation: PVOID,
HeapInformationLength: SIZE_T,
) -> BOOL;
pub fn HeapSize(hHeap: HANDLE, dwFlags: DWORD, lpMem: LPCVOID) -> SIZE_T;
pub fn HeapSummary(hHeap: HANDLE, dwFlags: DWORD, lpSummary: LPHEAP_SUMMARY) -> BOOL;
pub fn HeapUnlock(hHeap: HANDLE) -> BOOL;
pub fn HeapValidate(hHeap: HANDLE, dwFlags: DWORD, lpMem: LPCVOID) -> BOOL;
pub fn HeapWalk(hHeap: HANDLE, lpEntry: LPPROCESS_HEAP_ENTRY) -> BOOL;
pub fn InitAtomTable(nSize: DWORD) -> BOOL;
pub fn InitOnceBeginInitialize(
lpInitOnce: LPINIT_ONCE, dwFlags: DWORD, fPending: PBOOL, lpContext: *mut LPVOID,
) -> BOOL;
pub fn InitOnceComplete(
lpInitOnce: LPINIT_ONCE, dwFlags: DWORD, lpContext: LPVOID,
) -> BOOL;
pub fn InitOnceExecuteOnce(
InitOnce: PINIT_ONCE, InitFn: PINIT_ONCE_FN, Parameter: PVOID, Context: *mut LPVOID,
) -> BOOL;
pub fn InitOnceInitialize(InitOnce: PINIT_ONCE);
pub fn InitializeConditionVariable(ConditionVariable: PCONDITION_VARIABLE);
pub fn InitializeContext(
Buffer: PVOID, ContextFlags: DWORD, Context: *mut PCONTEXT, ContextLength: PDWORD,
) -> BOOL;
pub fn InitializeCriticalSection(lpCriticalSection: LPCRITICAL_SECTION);
pub fn InitializeCriticalSectionAndSpinCount(
lpCriticalSection: LPCRITICAL_SECTION, dwSpinCount: DWORD,
) -> BOOL;
pub fn InitializeCriticalSectionEx(
lpCriticalSection: LPCRITICAL_SECTION, dwSpinCount: DWORD, Flags: DWORD,
) -> BOOL;
pub fn InitializeProcThreadAttributeList(
lpAttributeList: LPPROC_THREAD_ATTRIBUTE_LIST, dwAttributeCount: DWORD, dwFlags: DWORD,
lpSize: PSIZE_T,
) -> BOOL;
pub fn InitializeSListHead(ListHead: PSLIST_HEADER);
pub fn InitializeSRWLock(SRWLock: PSRWLOCK);
pub fn InitializeSynchronizationBarrier(
lpBarrier: LPSYNCHRONIZATION_BARRIER, lTotalThreads: LONG, lSpinCount: LONG,
) -> BOOL;
pub fn InstallELAMCertificateInfo(ELAMFile: HANDLE) -> BOOL;
#[cfg(target_arch = "x86")]
pub fn InterlockedCompareExchange(
Destination: *mut LONG, ExChange: LONG, Comperand: LONG,
) -> LONG;
#[cfg(target_arch = "x86")]
pub fn InterlockedCompareExchange64(
Destination: *mut LONG64, ExChange: LONG64, Comperand: LONG64,
) -> LONG64;
#[cfg(target_arch = "x86")]
pub fn InterlockedDecrement(Addend: *mut LONG) -> LONG;
#[cfg(target_arch = "x86")]
pub fn InterlockedExchange(Target: *mut LONG, Value: LONG) -> LONG;
#[cfg(target_arch = "x86")]
pub fn InterlockedExchangeAdd(Addend: *mut LONG, Value: LONG) -> LONG;
pub fn InterlockedFlushSList(ListHead: PSLIST_HEADER) -> PSLIST_ENTRY;
#[cfg(target_arch = "x86")]
pub fn InterlockedIncrement(Addend: *mut LONG) -> LONG;
pub fn InterlockedPopEntrySList(ListHead: PSLIST_HEADER) -> PSLIST_ENTRY;
pub fn InterlockedPushEntrySList(
ListHead: PSLIST_HEADER, ListEntry: PSLIST_ENTRY,
) -> PSLIST_ENTRY;
pub fn InterlockedPushListSListEx(
ListHead: PSLIST_HEADER, List: PSLIST_ENTRY, ListEnd: PSLIST_ENTRY, Count: ULONG,
) -> PSLIST_ENTRY;
pub fn IsBadCodePtr(lpfn: FARPROC) -> BOOL;
pub fn IsBadHugeReadPtr(lp: *const VOID, ucb: UINT_PTR) -> BOOL;
pub fn IsBadHugeWritePtr(lp: LPVOID, ucb: UINT_PTR) -> BOOL;
pub fn IsBadReadPtr(lp: *const VOID, ucb: UINT_PTR) -> BOOL;
pub fn IsBadStringPtrA(lpsz: LPCSTR, ucchMax: UINT_PTR) -> BOOL;
pub fn IsBadStringPtrW(lpsz: LPCWSTR, ucchMax: UINT_PTR) -> BOOL;
pub fn IsBadWritePtr(lp: LPVOID, ucb: UINT_PTR) -> BOOL;
pub fn IsDBCSLeadByte(TestChar: BYTE) -> BOOL;
pub fn IsDBCSLeadByteEx(CodePage: UINT, TestChar: BYTE) -> BOOL;
pub fn IsDebuggerPresent() -> BOOL;
pub fn IsNLSDefinedString(
Function: NLS_FUNCTION, dwFlags: DWORD, lpVersionInformation: LPNLSVERSIONINFO,
lpString: LPCWSTR, cchStr: INT,
) -> BOOL;
pub fn IsNativeVhdBoot(NativeVhdBoot: PBOOL) -> BOOL;
pub fn IsNormalizedString(NormForm: NORM_FORM, lpString: LPCWSTR, cwLength: c_int) -> BOOL;
pub fn IsProcessCritical(hProcess: HANDLE, Critical: PBOOL) -> BOOL;
pub fn IsProcessInJob(ProcessHandle: HANDLE, JobHandle: HANDLE, Result: PBOOL) -> BOOL;
pub fn IsProcessorFeaturePresent(ProcessorFeature: DWORD) -> BOOL;
pub fn IsSystemResumeAutomatic() -> BOOL;
pub fn IsThreadAFiber() -> BOOL;
pub fn IsThreadpoolTimerSet(pti: PTP_TIMER) -> BOOL;
pub fn IsValidCodePage(CodePage: UINT) -> BOOL;
pub fn IsValidLanguageGroup(LanguageGroup: LGRPID, dwFlags: DWORD) -> BOOL;
pub fn IsValidLocale(Locale: LCID, dwFlags: DWORD) -> BOOL;
pub fn IsValidLocaleName(lpLocaleName: LPCWSTR) -> BOOL;
pub fn IsValidNLSVersion(
function: NLS_FUNCTION, lpLocaleName: LPCWSTR, lpVersionInformation: LPNLSVERSIONINFOEX,
) -> BOOL;
pub fn IsWow64Process(hProcess: HANDLE, Wow64Process: PBOOL) -> BOOL;
pub fn K32EmptyWorkingSet(hProcess: HANDLE) -> BOOL;
pub fn K32EnumDeviceDrivers(lpImageBase: *mut LPVOID, cb: DWORD, lpcbNeeded: LPDWORD) -> BOOL;
pub fn K32EnumPageFilesA(
pCallBackRoutine: PENUM_PAGE_FILE_CALLBACKA, pContext: LPVOID,
) -> BOOL;
pub fn K32EnumPageFilesW(
pCallBackRoutine: PENUM_PAGE_FILE_CALLBACKW, pContext: LPVOID,
) -> BOOL;
pub fn K32EnumProcessModules(
hProcess: HANDLE, lphModule: *mut HMODULE, cb: DWORD, lpcbNeeded: LPDWORD,
) -> BOOL;
pub fn K32EnumProcessModulesEx(
hProcess: HANDLE, lphModule: *mut HMODULE, cb: DWORD, lpcbNeeded: LPDWORD,
dwFilterFlag: DWORD,
) -> BOOL;
pub fn K32EnumProcesses(
lpidProcess: *mut DWORD, cb: DWORD, lpcbNeeded: LPDWORD,
) -> BOOL;
pub fn K32GetDeviceDriverBaseNameA(ImageBase: LPVOID, lpFilename: LPSTR, nSize: DWORD) -> DWORD;
pub fn K32GetDeviceDriverBaseNameW(
ImageBase: LPVOID, lpFilename: LPWSTR, nSize: DWORD,
) -> DWORD;
pub fn K32GetDeviceDriverFileNameA(ImageBase: LPVOID, lpFilename: LPSTR, nSize: DWORD) -> DWORD;
pub fn K32GetDeviceDriverFileNameW(
ImageBase: LPVOID, lpFilename: LPWSTR, nSize: DWORD,
) -> DWORD;
pub fn K32GetMappedFileNameA(
hProcess: HANDLE, lpv: LPVOID, lpFilename: LPSTR, nSize: DWORD,
) -> DWORD;
pub fn K32GetMappedFileNameW(
hProcess: HANDLE, lpv: LPVOID, lpFilename: LPWSTR, nSize: DWORD,
) -> DWORD;
pub fn K32GetModuleBaseNameA(
hProcess: HANDLE, hModule: HMODULE, lpBaseName: LPSTR, nSize: DWORD,
) -> DWORD;
pub fn K32GetModuleBaseNameW(
hProcess: HANDLE, hModule: HMODULE, lpBaseName: LPWSTR, nSize: DWORD,
) -> DWORD;
pub fn K32GetModuleFileNameExA(
hProcess: HANDLE, hModule: HMODULE, lpFilename: LPSTR, nSize: DWORD,
) -> DWORD;
pub fn K32GetModuleFileNameExW(
hProcess: HANDLE, hModule: HMODULE, lpFilename: LPWSTR, nSize: DWORD,
) -> DWORD;
pub fn K32GetModuleInformation(
hProcess: HANDLE, hModule: HMODULE, lpmodinfo: LPMODULEINFO, cb: DWORD,
) -> BOOL;
pub fn K32GetPerformanceInfo(
pPerformanceInformation: PPERFORMANCE_INFORMATION, cb: DWORD,
) -> BOOL;
pub fn K32GetProcessImageFileNameA(
hProcess: HANDLE, lpImageFileName: LPSTR, nSize: DWORD,
) -> DWORD;
pub fn K32GetProcessImageFileNameW(
hProcess: HANDLE, lpImageFileName: LPWSTR, nSize: DWORD,
) -> DWORD;
pub fn K32GetProcessMemoryInfo(
Process: HANDLE, ppsmemCounters: PPROCESS_MEMORY_COUNTERS, cb: DWORD,
) -> BOOL;
pub fn K32GetWsChanges(
hProcess: HANDLE, lpWatchInfo: PPSAPI_WS_WATCH_INFORMATION, cb: DWORD,
) -> BOOL;
pub fn K32GetWsChangesEx(
hProcess: HANDLE, lpWatchInfoEx: PPSAPI_WS_WATCH_INFORMATION_EX, cb: DWORD,
) -> BOOL;
pub fn K32InitializeProcessForWsWatch(hProcess: HANDLE) -> BOOL;
pub fn K32QueryWorkingSet(hProcess: HANDLE, pv: PVOID, cb: DWORD) -> BOOL;
pub fn K32QueryWorkingSetEx(hProcess: HANDLE, pv: PVOID, cb: DWORD) -> BOOL;
pub fn LCIDToLocaleName(Locale: LCID, lpName: LPWSTR, cchName: c_int, dwFlags: DWORD) -> c_int;
pub fn LCMapStringA(
Locale: LCID, dwMapFlags: DWORD, lpSrcStr: LPCSTR, cchSrc: c_int, lpDestStr: LPSTR,
cchDest: c_int,
) -> c_int;
pub fn LCMapStringEx(
lpLocaleName: LPCWSTR, dwMapFlags: DWORD, lpSrcStr: LPCWSTR, cchSrc: c_int,
lpDestStr: LPWSTR, cchDest: c_int, lpVersionInformation: LPNLSVERSIONINFO,
lpReserved: LPVOID, sortHandle: LPARAM,
) -> c_int;
pub fn LCMapStringW(
Locale: LCID, dwMapFlags: DWORD, lpSrcStr: LPCWSTR, cchSrc: c_int, lpDestStr: LPWSTR,
cchDest: c_int,
) -> c_int;
pub fn LeaveCriticalSection(lpCriticalSection: LPCRITICAL_SECTION);
pub fn LeaveCriticalSectionWhenCallbackReturns(
pci: PTP_CALLBACK_INSTANCE, pcs: PCRITICAL_SECTION,
);
pub fn LoadLibraryA(lpFileName: LPCSTR) -> HMODULE;
pub fn LoadLibraryExA(lpLibFileName: LPCSTR, hFile: HANDLE, dwFlags: DWORD) -> HMODULE;
pub fn LoadLibraryExW(lpLibFileName: LPCWSTR, hFile: HANDLE, dwFlags: DWORD) -> HMODULE;
pub fn LoadLibraryW(lpFileName: LPCWSTR) -> HMODULE;
pub fn LoadModule(lpModuleName: LPCSTR, lpParameterBlock: LPVOID) -> DWORD;
pub fn LoadPackagedLibrary(lpwLibFileName: LPCWSTR, Reserved: DWORD) -> HMODULE;
pub fn LoadResource(hModule: HMODULE, hResInfo: HRSRC) -> HGLOBAL;
pub fn LocalAlloc(uFlags: UINT, uBytes: SIZE_T) -> HLOCAL;
pub fn LocalCompact(uMinFree: UINT) -> SIZE_T;
pub fn LocalFileTimeToFileTime(
lpLocalFileTime: *const FILETIME, lpFileTime: LPFILETIME,
) -> BOOL;
pub fn LocalFlags(hMem: HLOCAL) -> UINT;
pub fn LocalFree(hMem: HLOCAL) -> HLOCAL;
pub fn LocalHandle(pMem: LPCVOID) -> HLOCAL;
pub fn LocalLock(hMem: HLOCAL) -> LPVOID;
pub fn LocalReAlloc(hMem: HLOCAL, uBytes: SIZE_T, uFlags: UINT) -> HLOCAL;
pub fn LocalShrink(hMem: HLOCAL, cbNewSize: UINT) -> SIZE_T;
pub fn LocalSize(hMem: HLOCAL) -> SIZE_T;
pub fn LocalUnlock(hMem: HLOCAL) -> BOOL;
pub fn LocaleNameToLCID(lpName: LPCWSTR, dwFlags: DWORD) -> LCID;
#[cfg(any(target_arch = "x86", target_arch = "x86_64"))]
pub fn LocateXStateFeature(Context: PCONTEXT, FeatureId: DWORD, Length: PDWORD) -> PVOID;
pub fn LockFile(
hFile: HANDLE, dwFileOffsetLow: DWORD, dwFileOffsetHigh: DWORD,
nNumberOfBytesToLockLow: DWORD, nNumberOfBytesToLockHigh: DWORD,
) -> BOOL;
pub fn LockFileEx(
hFile: HANDLE, dwFlags: DWORD, dwReserved: DWORD, nNumberOfBytesToLockLow: DWORD,
nNumberOfBytesToLockHigh: DWORD, lpOverlapped: LPOVERLAPPED,
) -> BOOL;
pub fn LockResource(hResData: HGLOBAL) -> LPVOID;
pub fn MapUserPhysicalPages(
VirtualAddress: PVOID, NumberOfPages: ULONG_PTR, PageArray: PULONG_PTR,
) -> BOOL;
pub fn MapUserPhysicalPagesScatter(
VirtualAddresses: *mut PVOID, NumberOfPages: ULONG_PTR, PageArray: PULONG_PTR,
) -> BOOL;
pub fn MapViewOfFile(
hFileMappingObject: HANDLE, dwDesiredAccess: DWORD, dwFileOffsetHigh: DWORD,
dwFileOffsetLow: DWORD, dwNumberOfBytesToMap: SIZE_T,
) -> LPVOID;
pub fn MapViewOfFileEx(
hFileMappingObject: HANDLE, dwDesiredAccess: DWORD, dwFileOffsetHigh: DWORD,
dwFileOffsetLow: DWORD, dwNumberOfBytesToMap: SIZE_T, lpBaseAddress: LPVOID,
) -> LPVOID;
pub fn MapViewOfFileExNuma(
hFileMappingObject: HANDLE, dwDesiredAccess: DWORD, dwFileOffsetHigh: DWORD,
dwFileOffsetLow: DWORD, dwNumberOfBytesToMap: SIZE_T, lpBaseAddress: LPVOID,
nndPreferred: DWORD,
) -> LPVOID;
pub fn MapViewOfFileFromApp(
hFileMappingObject: HANDLE, DesiredAccess: DWORD, FileOffset: ULONG64,
NumberOfBytesToMap: SIZE_T,
) -> PVOID;
pub fn Module32First(hSnapshot: HANDLE, lpme: LPMODULEENTRY32) -> BOOL;
pub fn Module32FirstW(hSnapshot: HANDLE, lpme: LPMODULEENTRY32W) -> BOOL;
pub fn Module32Next(hSnapshot: HANDLE, lpme: LPMODULEENTRY32) -> BOOL;
pub fn Module32NextW(hSnapshot: HANDLE, lpme: LPMODULEENTRY32W) -> BOOL;
pub fn MoveFileA(lpExistingFileName: LPCSTR, lpNewFileName: LPCSTR) -> BOOL;
pub fn MoveFileExA(lpExistingFileName: LPCSTR, lpNewFileName: LPCSTR, dwFlags: DWORD) -> BOOL;
pub fn MoveFileExW(lpExistingFileName: LPCWSTR, lpNewFileName: LPCWSTR, dwFlags: DWORD) -> BOOL;
pub fn MoveFileTransactedA(
lpExistingFileName: LPCSTR, lpNewFileName: LPCSTR, lpProgressRoutine: LPPROGRESS_ROUTINE,
lpData: LPVOID, dwFlags: DWORD, hTransaction: HANDLE,
) -> BOOL;
pub fn MoveFileTransactedW(
lpExistingFileName: LPCWSTR, lpNewFileName: LPCWSTR, lpProgressRoutine: LPPROGRESS_ROUTINE,
lpData: LPVOID, dwFlags: DWORD, hTransaction: HANDLE,
) -> BOOL;
pub fn MoveFileW(lpExistingFileName: LPCWSTR, lpNewFileName: LPCWSTR) -> BOOL;
pub fn MoveFileWithProgressA(
lpExistingFileName: LPCSTR, lpNewFileName: LPCSTR, lpProgressRoutine: LPPROGRESS_ROUTINE,
lpData: LPVOID, dwFlags: DWORD,
) -> BOOL;
pub fn MoveFileWithProgressW(
lpExistingFileName: LPCWSTR, lpNewFileName: LPCWSTR, lpProgressRoutine: LPPROGRESS_ROUTINE,
lpData: LPVOID, dwFlags: DWORD,
) -> BOOL;
pub fn MulDiv(nNumber: c_int, nNumerator: c_int, nDenominator: c_int) -> c_int;
pub fn MultiByteToWideChar(
CodePage: UINT, dwFlags: DWORD, lpMultiByteStr: LPCCH, cbMultiByte: c_int,
lpWideCharStr: LPWSTR, cchWideChar: c_int,
) -> c_int;
pub fn NeedCurrentDirectoryForExePathA(ExeName: LPCSTR) -> BOOL;
pub fn NeedCurrentDirectoryForExePathW(ExeName: LPCWSTR) -> BOOL;
pub fn NormalizeString(
NormForm: NORM_FORM, lpSrcString: LPCWSTR, cwSrcLength: c_int, lpDstString: LPWSTR,
cwDstLength: c_int,
) -> c_int;
pub fn NotifyUILanguageChange(
dwFlags: DWORD, pcwstrNewLanguage: PCWSTR, pcwstrPreviousLanguage: PCWSTR,
dwReserved: DWORD, pdwStatusRtrn: PDWORD,
) -> BOOL;
pub fn OpenEventA(dwDesiredAccess: DWORD, bInheritHandle: BOOL, lpName: LPCSTR) -> HANDLE;
pub fn OpenEventW(dwDesiredAccess: DWORD, bInheritHandle: BOOL, lpName: LPCWSTR) -> HANDLE;
pub fn OpenFile(lpFileName: LPCSTR, lpReOpenBuff: LPOFSTRUCT, uStyle: UINT) -> HFILE;
pub fn OpenFileById(
hVolumeHint: HANDLE, lpFileId: LPFILE_ID_DESCRIPTOR, dwDesiredAccess: DWORD,
dwShareMode: DWORD, lpSecurityAttributes: LPSECURITY_ATTRIBUTES,
dwFlagsAndAttributes: DWORD,
) -> HANDLE;
pub fn OpenFileMappingA(
dwDesiredAccess: DWORD, bInheritHandle: BOOL, lpName: LPCSTR,
) -> HANDLE;
pub fn OpenFileMappingW(
dwDesiredAccess: DWORD, bInheritHandle: BOOL, lpName: LPCWSTR,
) -> HANDLE;
pub fn OpenJobObjectA(dwDesiredAccess: DWORD, bInheritHandle: BOOL, lpName: LPCSTR) -> HANDLE;
pub fn OpenJobObjectW(dwDesiredAccess: DWORD, bInheritHandle: BOOL, lpName: LPCWSTR) -> HANDLE;
pub fn OpenMutexA(dwDesiredAccess: DWORD, bInheritHandle: BOOL, lpName: LPCSTR) -> HANDLE;
pub fn OpenMutexW(dwDesiredAccess: DWORD, bInheritHandle: BOOL, lpName: LPCWSTR) -> HANDLE;
pub fn OpenPrivateNamespaceA(lpBoundaryDescriptor: LPVOID, lpAliasPrefix: LPCSTR) -> HANDLE;
pub fn OpenPrivateNamespaceW(lpBoundaryDescriptor: LPVOID, lpAliasPrefix: LPCWSTR) -> HANDLE;
pub fn OpenProcess(dwDesiredAccess: DWORD, bInheritHandle: BOOL, dwProcessId: DWORD) -> HANDLE;
pub fn OpenSemaphoreA(dwDesiredAccess: DWORD, bInheritHandle: BOOL, lpName: LPCSTR) -> HANDLE;
pub fn OpenSemaphoreW(dwDesiredAccess: DWORD, bInheritHandle: BOOL, lpName: LPCWSTR) -> HANDLE;
pub fn OpenThread(dwDesiredAccess: DWORD, bInheritHandle: BOOL, dwThreadId: DWORD) -> HANDLE;
pub fn OpenWaitableTimerA(
dwDesiredAccess: DWORD, bInheritHandle: BOOL, lpTimerName: LPCSTR,
) -> HANDLE;
pub fn OpenWaitableTimerW(
dwDesiredAccess: DWORD, bInheritHandle: BOOL, lpTimerName: LPCWSTR,
) -> HANDLE;
pub fn OutputDebugStringA(lpOutputString: LPCSTR);
pub fn OutputDebugStringW(lpOutputString: LPCWSTR);
pub fn PeekConsoleInputA(
hConsoleInput: HANDLE, lpBuffer: PINPUT_RECORD, nLength: DWORD,
lpNumberOfEventsRead: LPDWORD,
) -> BOOL;
pub fn PeekConsoleInputW(
hConsoleInput: HANDLE, lpBuffer: PINPUT_RECORD, nLength: DWORD,
lpNumberOfEventsRead: LPDWORD,
) -> BOOL;
pub fn PeekNamedPipe(
hNamedPipe: HANDLE, lpBuffer: LPVOID, nBufferSize: DWORD, lpBytesRead: LPDWORD,
lpTotalBytesAvail: LPDWORD, lpBytesLeftThisMessage: LPDWORD,
) -> BOOL;
pub fn PostQueuedCompletionStatus(
CompletionPort: HANDLE, dwNumberOfBytesTransferred: DWORD, dwCompletionKey: ULONG_PTR,
lpOverlapped: LPOVERLAPPED,
) -> BOOL;
pub fn PowerClearRequest(PowerRequest: HANDLE, RequestType: POWER_REQUEST_TYPE) -> BOOL;
pub fn PowerCreateRequest(Context: PREASON_CONTEXT) -> HANDLE;
pub fn PowerSetRequest(PowerRequest: HANDLE, RequestType: POWER_REQUEST_TYPE) -> BOOL;
pub fn PrefetchVirtualMemory(
hProcess: HANDLE, NumberOfEntries: ULONG_PTR, VirtualAddresses: PWIN32_MEMORY_RANGE_ENTRY,
Flags: ULONG,
) -> BOOL;
pub fn PrepareTape(hDevice: HANDLE, dwOperation: DWORD, bImmediate: BOOL) -> DWORD;
pub fn Process32First(hSnapshot: HANDLE, lppe: LPPROCESSENTRY32) -> BOOL;
pub fn Process32FirstW(hSnapshot: HANDLE, lppe: LPPROCESSENTRY32W) -> BOOL;
pub fn Process32Next(hSnapshot: HANDLE, lppe: LPPROCESSENTRY32) -> BOOL;
pub fn Process32NextW(hSnapshot: HANDLE, lppe: LPPROCESSENTRY32W) -> BOOL;
pub fn ProcessIdToSessionId(dwProcessId: DWORD, pSessionId: *mut DWORD) -> BOOL;
pub fn PssCaptureSnapshot(
ProcessHandle: HANDLE, CaptureFlags: PSS_CAPTURE_FLAGS, ThreadContextFlags: DWORD,
SnapshotHandle: *mut HPSS,
) -> DWORD;
pub fn PssDuplicateSnapshot(
SourceProcessHandle: HANDLE, SnapshotHandle: HPSS, TargetProcessHandle: HANDLE,
TargetSnapshotHandle: *mut HPSS, Flags: PSS_DUPLICATE_FLAGS,
) -> DWORD;
pub fn PssFreeSnapshot(ProcessHandle: HANDLE, SnapshotHandle: HPSS) -> DWORD;
pub fn PssQuerySnapshot(
SnapshotHandle: HPSS, InformationClass: PSS_QUERY_INFORMATION_CLASS, Buffer: *mut c_void,
BufferLength: DWORD,
) -> DWORD;
pub fn PssWalkMarkerCreate(
Allocator: *const PSS_ALLOCATOR, WalkMarkerHandle: *mut HPSSWALK,
) -> DWORD;
pub fn PssWalkMarkerFree(WalkMarkerHandle: HPSSWALK) -> DWORD;
pub fn PssWalkMarkerGetPosition(WalkMarkerHandle: HPSSWALK, Position: *mut ULONG_PTR) -> DWORD;
pub fn PssWalkMarkerSeekToBeginning(WalkMarkerHandle: HPSSWALK) -> DWORD;
pub fn PssWalkMarkerSetPosition(WalkMarkerHandle: HPSSWALK, Position: ULONG_PTR) -> DWORD;
pub fn PssWalkSnapshot(
SnapshotHandle: HPSS, InformationClass: PSS_WALK_INFORMATION_CLASS,
WalkMarkerHandle: HPSSWALK, Buffer: *mut c_void, BufferLength: DWORD,
) -> DWORD;
pub fn PulseEvent(hEvent: HANDLE) -> BOOL;
pub fn PurgeComm(hFile: HANDLE, dwFlags: DWORD) -> BOOL;
pub fn QueryActCtxSettingsW(
dwFlags: DWORD, hActCtx: HANDLE, settingsNameSpace: PCWSTR, settingName: PCWSTR,
pvBuffer: PWSTR, dwBuffer: SIZE_T, pdwWrittenOrRequired: *mut SIZE_T,
) -> BOOL;
pub fn QueryActCtxW(
dwFlags: DWORD, hActCtx: HANDLE, pvSubInstance: PVOID, ulInfoClass: ULONG, pvBuffer: PVOID,
cbBuffer: SIZE_T, pcbWrittenOrRequired: *mut SIZE_T,
) -> BOOL;
pub fn QueryDepthSList(ListHead: PSLIST_HEADER) -> USHORT;
pub fn QueryDosDeviceA(lpDeviceName: LPCSTR, lpTargetPath: LPSTR, ucchMax: DWORD) -> DWORD;
pub fn QueryDosDeviceW(lpDeviceName: LPCWSTR, lpTargetPath: LPWSTR, ucchMax: DWORD) -> DWORD;
pub fn QueryFullProcessImageNameA(
hProcess: HANDLE, dwFlags: DWORD, lpExeName: LPSTR, lpdwSize: PDWORD,
) -> BOOL;
pub fn QueryFullProcessImageNameW(
hProcess: HANDLE, dwFlags: DWORD, lpExeName: LPWSTR, lpdwSize: PDWORD,
) -> BOOL;
pub fn QueryIdleProcessorCycleTime(
BufferLength: PULONG, ProcessorIdleCycleTime: PULONG64,
) -> BOOL;
pub fn QueryIdleProcessorCycleTimeEx(
Group: USHORT, BufferLength: PULONG, ProcessorIdleCycleTime: PULONG64,
) -> BOOL;
pub fn QueryInformationJobObject(
hJob: HANDLE, JobObjectInformationClass: JOBOBJECTINFOCLASS,
lpJobObjectInformation: LPVOID, cbJobObjectInformationLength: DWORD,
lpReturnLength: LPDWORD,
) -> BOOL;
pub fn QueryMemoryResourceNotification(
ResourceNotificationHandle: HANDLE, ResourceState: PBOOL,
) -> BOOL;
pub fn QueryPerformanceCounter(lpPerformanceCount: *mut LARGE_INTEGER) -> BOOL;
pub fn QueryPerformanceFrequency(lpFrequency: *mut LARGE_INTEGER) -> BOOL;
pub fn QueryProcessAffinityUpdateMode(hProcess: HANDLE, lpdwFlags: LPDWORD) -> BOOL;
pub fn QueryProcessCycleTime(ProcessHandle: HANDLE, CycleTime: PULONG64) -> BOOL;
pub fn QueryProtectedPolicy(PolicyGuid: LPCGUID, PolicyValue: PULONG_PTR) -> BOOL;
pub fn QueryThreadCycleTime(ThreadHandle: HANDLE, CycleTime: PULONG64) -> BOOL;
pub fn QueryThreadProfiling(ThreadHandle: HANDLE, Enabled: PBOOLEAN) -> DWORD;
pub fn QueryThreadpoolStackInformation(
ptpp: PTP_POOL, ptpsi: PTP_POOL_STACK_INFORMATION,
) -> BOOL;
#[cfg(target_arch = "x86_64")]
pub fn QueryUmsThreadInformation(
UmsThread: PUMS_CONTEXT, UmsThreadInfoClass: UMS_THREAD_INFO_CLASS,
UmsThreadInformation: PVOID, UmsThreadInformationLength: ULONG, ReturnLength: PULONG,
);
pub fn QueryUnbiasedInterruptTime(UnbiasedTime: PULONGLONG) -> BOOL;
pub fn QueueUserAPC(pfnAPC: PAPCFUNC, hThread: HANDLE, dwData: ULONG_PTR) -> DWORD;
pub fn QueueUserWorkItem(
Function: LPTHREAD_START_ROUTINE, Context: PVOID, Flags: ULONG,
) -> BOOL;
pub fn RaiseException(
dwExceptionCode: DWORD, dwExceptionFlags: DWORD, nNumberOfArguments: DWORD,
lpArguments: *const ULONG_PTR,
);
pub fn RaiseFailFastException(
pExceptionRecord: PEXCEPTION_RECORD, pContextRecord: PCONTEXT, dwFlags: DWORD,
);
pub fn ReOpenFile(
hOriginalFile: HANDLE, dwDesiredAccess: DWORD, dwShareMode: DWORD, dwFlags: DWORD,
) -> HANDLE;
pub fn ReadConsoleA(
hConsoleInput: HANDLE, lpBuffer: LPVOID, nNumberOfCharsToRead: DWORD,
lpNumberOfCharsRead: LPDWORD, pInputControl: PCONSOLE_READCONSOLE_CONTROL,
) -> BOOL;
pub fn ReadConsoleInputA(
hConsoleInput: HANDLE, lpBuffer: PINPUT_RECORD, nLength: DWORD,
lpNumberOfEventsRead: LPDWORD,
) -> BOOL;
pub fn ReadConsoleInputW(
hConsoleInput: HANDLE, lpBuffer: PINPUT_RECORD, nLength: DWORD,
lpNumberOfEventsRead: LPDWORD,
) -> BOOL;
pub fn ReadConsoleOutputA(
hConsoleOutput: HANDLE, lpBuffer: PCHAR_INFO, dwBufferSize: COORD, dwBufferCoord: COORD,
lpReadRegion: PSMALL_RECT,
) -> BOOL;
pub fn ReadConsoleOutputAttribute(
hConsoleOutput: HANDLE, lpAttribute: LPWORD, nLength: DWORD, dwReadCoord: COORD,
lpNumberOfAttrsRead: LPDWORD,
) -> BOOL;
pub fn ReadConsoleOutputCharacterA(
hConsoleOutput: HANDLE, lpCharacter: LPSTR, nLength: DWORD, dwReadCoord: COORD,
lpNumberOfCharsRead: LPDWORD,
) -> BOOL;
pub fn ReadConsoleOutputCharacterW(
hConsoleOutput: HANDLE, lpCharacter: LPWSTR, nLength: DWORD, dwReadCoord: COORD,
lpNumberOfCharsRead: LPDWORD,
) -> BOOL;
pub fn ReadConsoleOutputW(
hConsoleOutput: HANDLE, lpBuffer: PCHAR_INFO, dwBufferSize: COORD, dwBufferCoord: COORD,
lpReadRegion: PSMALL_RECT,
) -> BOOL;
pub fn ReadConsoleW(
hConsoleInput: HANDLE, lpBuffer: LPVOID, nNumberOfCharsToRead: DWORD,
lpNumberOfCharsRead: LPDWORD, pInputControl: PCONSOLE_READCONSOLE_CONTROL,
) -> BOOL;
pub fn ReadDirectoryChangesW(
hDirectory: HANDLE, lpBuffer: LPVOID, nBufferLength: DWORD, bWatchSubtree: BOOL,
dwNotifyFilter: DWORD, lpBytesReturned: LPDWORD, lpOverlapped: LPOVERLAPPED,
lpCompletionRoutine: LPOVERLAPPED_COMPLETION_ROUTINE,
) -> BOOL;
pub fn ReadFile(
hFile: HANDLE, lpBuffer: LPVOID, nNumberOfBytesToRead: DWORD, lpNumberOfBytesRead: LPDWORD,
lpOverlapped: LPOVERLAPPED,
) -> BOOL;
pub fn ReadFileEx(
hFile: HANDLE, lpBuffer: LPVOID, nNumberOfBytesToRead: DWORD, lpOverlapped: LPOVERLAPPED,
lpCompletionRoutine: LPOVERLAPPED_COMPLETION_ROUTINE,
) -> BOOL;
pub fn ReadFileScatter(
hFile: HANDLE, aSegmentArray: *mut FILE_SEGMENT_ELEMENT, nNumberOfBytesToRead: DWORD,
lpReserved: LPDWORD, lpOverlapped: LPOVERLAPPED,
) -> BOOL;
pub fn ReadProcessMemory(
hProcess: HANDLE, lpBaseAddress: LPCVOID, lpBuffer: LPVOID, nSize: SIZE_T,
lpNumberOfBytesRead: *mut SIZE_T,
) -> BOOL;
pub fn ReadThreadProfilingData(
PerformanceDataHandle: HANDLE, Flags: DWORD, PerformanceData: PPERFORMANCE_DATA,
) -> DWORD;
pub fn RegisterApplicationRecoveryCallback(
pRecoveyCallback: APPLICATION_RECOVERY_CALLBACK, pvParameter: PVOID, dwPingInterval: DWORD,
dwFlags: DWORD,
) -> HRESULT;
pub fn RegisterApplicationRestart(pwzCommandline: PCWSTR, dwFlags: DWORD) -> HRESULT;
pub fn RegisterBadMemoryNotification(Callback: PBAD_MEMORY_CALLBACK_ROUTINE) -> PVOID;
pub fn RegisterWaitForSingleObject(
phNewWaitObject: PHANDLE, hObject: HANDLE, Callback: WAITORTIMERCALLBACK, Context: PVOID,
dwMilliseconds: ULONG, dwFlags: ULONG,
) -> BOOL;
pub fn RegisterWaitForSingleObjectEx(
hObject: HANDLE, Callback: WAITORTIMERCALLBACK, Context: PVOID, dwMilliseconds: ULONG,
dwFlags: ULONG,
) -> HANDLE;
pub fn ReleaseActCtx(hActCtx: HANDLE);
pub fn ReleaseMutex(hMutex: HANDLE) -> BOOL;
pub fn ReleaseMutexWhenCallbackReturns(pci: PTP_CALLBACK_INSTANCE, mutex: HANDLE);
pub fn ReleaseSRWLockExclusive(SRWLock: PSRWLOCK);
pub fn ReleaseSRWLockShared(SRWLock: PSRWLOCK);
pub fn ReleaseSemaphore(
hSemaphore: HANDLE, lReleaseCount: LONG, lpPreviousCount: LPLONG,
) -> BOOL;
pub fn ReleaseSemaphoreWhenCallbackReturns(
pci: PTP_CALLBACK_INSTANCE, sem: HANDLE, crel: DWORD,
);
pub fn RemoveDirectoryA(lpPathName: LPCSTR) -> BOOL;
pub fn RemoveDirectoryTransactedA(lpPathName: LPCSTR, hTransaction: HANDLE) -> BOOL;
pub fn RemoveDirectoryTransactedW(lpPathName: LPCWSTR, hTransaction: HANDLE) -> BOOL;
pub fn RemoveDirectoryW(lpPathName: LPCWSTR) -> BOOL;
pub fn RemoveDllDirectory(Cookie: DLL_DIRECTORY_COOKIE) -> BOOL;
pub fn RemoveSecureMemoryCacheCallback(pfnCallBack: PSECURE_MEMORY_CACHE_CALLBACK) -> BOOL;
pub fn RemoveVectoredContinueHandler(Handle: PVOID) -> ULONG;
pub fn RemoveVectoredExceptionHandler(Handle: PVOID) -> ULONG;
pub fn ReplaceFileA(
lpReplacedFileName: LPCSTR, lpReplacementFileName: LPCSTR, lpBackupFileName: LPCSTR,
dwReplaceFlags: DWORD, lpExclude: LPVOID, lpReserved: LPVOID,
);
pub fn ReplaceFileW(
lpReplacedFileName: LPCWSTR, lpReplacementFileName: LPCWSTR, lpBackupFileName: LPCWSTR,
dwReplaceFlags: DWORD, lpExclude: LPVOID, lpReserved: LPVOID,
);
pub fn ReplacePartitionUnit(
TargetPartition: PWSTR, SparePartition: PWSTR, Flags: ULONG,
) -> BOOL;
pub fn RequestDeviceWakeup(hDevice: HANDLE) -> BOOL;
pub fn RequestWakeupLatency(latency: LATENCY_TIME) -> BOOL;
pub fn ResetEvent(hEvent: HANDLE) -> BOOL;
pub fn ResetWriteWatch(lpBaseAddress: LPVOID, dwRegionSize: SIZE_T) -> UINT;
pub fn ResolveLocaleName(
lpNameToResolve: LPCWSTR, lpLocaleName: LPWSTR, cchLocaleName: c_int,
) -> c_int;
pub fn RestoreLastError(dwErrCode: DWORD);
pub fn ResumeThread(hThread: HANDLE) -> DWORD;
#[cfg(target_arch = "arm")]
pub fn RtlAddFunctionTable(
FunctionTable: PRUNTIME_FUNCTION, EntryCount: DWORD, BaseAddress: DWORD,
) -> BOOLEAN;
#[cfg(target_arch = "x86_64")]
pub fn RtlAddFunctionTable(
FunctionTable: PRUNTIME_FUNCTION, EntryCount: DWORD, BaseAddress: DWORD64,
) -> BOOLEAN;
pub fn RtlCaptureContext(ContextRecord: PCONTEXT);
pub fn RtlCaptureStackBackTrace(
FramesToSkip: DWORD, FramesToCapture: DWORD, BackTrace: *mut PVOID, BackTraceHash: PDWORD,
) -> WORD;
pub fn RtlCompareMemory(Source1: *const VOID, Source2: *const VOID, Length: SIZE_T) -> SIZE_T;
pub fn RtlCopyMemory(Destination: PVOID, Source: *const VOID, Length: SIZE_T);
#[cfg(any(target_arch = "arm", target_arch = "x86_64"))]
pub fn RtlDeleteFunctionTable(FunctionTable: PRUNTIME_FUNCTION) -> BOOLEAN;
#[cfg(target_arch = "arm")]
pub fn RtlInstallFunctionTableCallback(
TableIdentifier: DWORD, BaseAddress: DWORD, Length: DWORD,
Callback: PGET_RUNTIME_FUNCTION_CALLBACK, Context: PVOID, OutOfProcessCallbackDll: PCWSTR,
) -> BOOLEAN;
#[cfg(target_arch = "x86_64")]
pub fn RtlInstallFunctionTableCallback(
TableIdentifier: DWORD64, BaseAddress: DWORD64, Length: DWORD,
Callback: PGET_RUNTIME_FUNCTION_CALLBACK, Context: PVOID, OutOfProcessCallbackDll: PCWSTR,
) -> BOOLEAN;
#[cfg(target_arch = "arm")]
pub fn RtlLookupFunctionEntry(
ControlPc: ULONG_PTR, ImageBase: PDWORD, HistoryTable: PUNWIND_HISTORY_TABLE,
) -> PRUNTIME_FUNCTION;
#[cfg(target_arch = "x86_64")]
pub fn RtlLookupFunctionEntry(
ControlPc: DWORD64, ImageBase: PDWORD64, HistoryTable: PUNWIND_HISTORY_TABLE,
) -> PRUNTIME_FUNCTION;
pub fn RtlPcToFileHeader(PcValue: PVOID, BaseOfImage: *mut PVOID) -> PVOID;
#[cfg(any(target_arch = "arm", target_arch = "x86_64"))]
pub fn RtlRestoreContext(ContextRecord: PCONTEXT, ExceptionRecord: *mut EXCEPTION_RECORD);
pub fn RtlUnwind(
TargetFrame: PVOID, TargetIp: PVOID, ExceptionRecord: PEXCEPTION_RECORD, ReturnValue: PVOID,
);
#[cfg(any(target_arch = "arm", target_arch = "x86_64"))]
pub fn RtlUnwindEx(
TargetFrame: PVOID, TargetIp: PVOID, ExceptionRecord: PEXCEPTION_RECORD, ReturnValue: PVOID,
ContextRecord: PCONTEXT, HistoryTable: PUNWIND_HISTORY_TABLE,
);
#[cfg(target_arch = "arm")]
pub fn RtlVirtualUnwind(
HandlerType: DWORD, ImageBase: DWORD, ControlPc: DWORD, FunctionEntry: PRUNTIME_FUNCTION,
ContextRecord: PCONTEXT, HandlerData: *mut PVOID, EstablisherFrame: PDWORD,
ContextPointers: PKNONVOLATILE_CONTEXT_POINTERS,
) -> PEXCEPTION_ROUTINE;
#[cfg(target_arch = "x86_64")]
pub fn RtlVirtualUnwind(
HandlerType: DWORD, ImageBase: DWORD64, ControlPc: DWORD64,
FunctionEntry: PRUNTIME_FUNCTION, ContextRecord: PCONTEXT, HandlerData: *mut PVOID,
EstablisherFrame: PDWORD64, ContextPointers: PKNONVOLATILE_CONTEXT_POINTERS,
) -> PEXCEPTION_ROUTINE;
pub fn ScrollConsoleScreenBufferA(
hConsoleOutput: HANDLE, lpScrollRectangle: *const SMALL_RECT,
lpClipRectangle: *const SMALL_RECT, dwDestinationOrigin: COORD, lpFill: *const CHAR_INFO,
) -> BOOL;
pub fn ScrollConsoleScreenBufferW(
hConsoleOutput: HANDLE, lpScrollRectangle: *const SMALL_RECT,
lpClipRectangle: *const SMALL_RECT, dwDestinationOrigin: COORD, lpFill: *const CHAR_INFO,
) -> BOOL;
pub fn SearchPathA(
lpPath: LPCSTR, lpFileName: LPCSTR, lpExtension: LPCSTR, nBufferLength: DWORD,
lpBuffer: LPSTR, lpFilePart: *mut LPSTR,
) -> DWORD;
pub fn SearchPathW(
lpPath: LPCWSTR, lpFileName: LPCWSTR, lpExtension: LPCWSTR, nBufferLength: DWORD,
lpBuffer: LPWSTR, lpFilePart: *mut LPWSTR,
) -> DWORD;
pub fn SetCachedSigningLevel(
SourceFiles: PHANDLE, SourceFileCount: ULONG, Flags: ULONG, TargetFile: HANDLE,
) -> BOOL;
pub fn SetCalendarInfoA(
Locale: LCID, Calendar: CALID, CalType: CALTYPE, lpCalData: LPCSTR,
) -> BOOL;
pub fn SetCalendarInfoW(
Locale: LCID, Calendar: CALID, CalType: CALTYPE, lpCalData: LPCWSTR,
) -> BOOL;
pub fn SetCommBreak(hFile: HANDLE) -> BOOL;
pub fn SetCommConfig(hCommDev: HANDLE, lpCC: LPCOMMCONFIG, dwSize: DWORD) -> BOOL;
pub fn SetCommMask(hFile: HANDLE, dwEvtMask: DWORD) -> BOOL;
pub fn SetCommState(hFile: HANDLE, lpDCB: LPDCB) -> BOOL;
pub fn SetCommTimeouts(hFile: HANDLE, lpCommTimeouts: LPCOMMTIMEOUTS) -> BOOL;
pub fn SetComputerNameA(lpComputerName: LPCSTR) -> BOOL;
pub fn SetComputerNameEx2W(
NameType: COMPUTER_NAME_FORMAT, Flags: DWORD, lpBuffer: LPCWSTR,
) -> BOOL;
pub fn SetComputerNameExA(NameType: COMPUTER_NAME_FORMAT, lpBuffer: LPCSTR) -> BOOL;
pub fn SetComputerNameExW(NameType: COMPUTER_NAME_FORMAT, lpBuffer: LPCWSTR) -> BOOL;
pub fn SetComputerNameW(lpComputerName: LPCWSTR) -> BOOL;
pub fn SetConsoleActiveScreenBuffer(hConsoleOutput: HANDLE) -> BOOL;
pub fn SetConsoleCP(wCodePageID: UINT) -> BOOL;
pub fn SetConsoleCtrlHandler(HandlerRoutine: PHANDLER_ROUTINE, Add: BOOL) -> BOOL;
pub fn SetConsoleCursorInfo(
hConsoleOutput: HANDLE, lpConsoleCursorInfo: *const CONSOLE_CURSOR_INFO,
) -> BOOL;
pub fn SetConsoleCursorPosition(hConsoleOutput: HANDLE, dwCursorPosition: COORD) -> BOOL;
pub fn SetConsoleDisplayMode(
hConsoleOutput: HANDLE, dwFlags: DWORD, lpNewScreenBufferDimensions: PCOORD,
) -> BOOL;
pub fn SetConsoleHistoryInfo(lpConsoleHistoryInfo: PCONSOLE_HISTORY_INFO) -> BOOL;
pub fn SetConsoleMode(hConsoleHandle: HANDLE, dwMode: DWORD) -> BOOL;
pub fn SetConsoleOutputCP(wCodePageID: UINT) -> BOOL;
pub fn SetConsoleScreenBufferInfoEx(
hConsoleOutput: HANDLE, lpConsoleScreenBufferInfoEx: PCONSOLE_SCREEN_BUFFER_INFOEX,
) -> BOOL;
pub fn SetConsoleScreenBufferSize(hConsoleOutput: HANDLE, dwSize: COORD) -> BOOL;
pub fn SetConsoleTextAttribute(hConsoleOutput: HANDLE, wAttributes: WORD) -> BOOL;
pub fn SetConsoleTitleA(lpConsoleTitle: LPCSTR) -> BOOL;
pub fn SetConsoleTitleW(lpConsoleTitle: LPCWSTR) -> BOOL;
pub fn SetConsoleWindowInfo(
hConsoleOutput: HANDLE, bAbsolute: BOOL, lpConsoleWindow: *const SMALL_RECT,
) -> BOOL;
pub fn SetCriticalSectionSpinCount(
lpCriticalSection: LPCRITICAL_SECTION, dwSpinCount: DWORD,
) -> DWORD;
pub fn SetCurrentConsoleFontEx(
hConsoleOutput: HANDLE, bMaximumWindow: BOOL, lpConsoleCurrentFontEx: PCONSOLE_FONT_INFOEX,
) -> BOOL;
pub fn SetCurrentDirectoryA(lpPathName: LPCSTR) -> BOOL;
pub fn SetCurrentDirectoryW(lpPathName: LPCWSTR) -> BOOL;
pub fn SetDefaultCommConfigA(lpszName: LPCSTR, lpCC: LPCOMMCONFIG, dwSize: DWORD) -> BOOL;
pub fn SetDefaultCommConfigW(lpszName: LPCWSTR, lpCC: LPCOMMCONFIG, dwSize: DWORD) -> BOOL;
pub fn SetDefaultDllDirectories(DirectoryFlags: DWORD) -> BOOL;
pub fn SetDllDirectoryA(lpPathName: LPCSTR) -> BOOL;
pub fn SetDllDirectoryW(lpPathName: LPCWSTR) -> BOOL;
pub fn SetDynamicTimeZoneInformation(
lpTimeZoneInformation: *const DYNAMIC_TIME_ZONE_INFORMATION,
) -> BOOL;
pub fn SetEndOfFile(hFile: HANDLE) -> BOOL;
pub fn SetEnvironmentStringsA(NewEnvironment: LPCH) -> BOOL;
pub fn SetEnvironmentStringsW(NewEnvironment: LPWCH) -> BOOL;
pub fn SetEnvironmentVariableA(lpName: LPCSTR, lpValue: LPCSTR) -> BOOL;
pub fn SetEnvironmentVariableW(lpName: LPCWSTR, lpValue: LPCWSTR) -> BOOL;
pub fn SetErrorMode(uMode: UINT) -> UINT;
pub fn SetEvent(hEvent: HANDLE) -> BOOL;
pub fn SetEventWhenCallbackReturns(pci: PTP_CALLBACK_INSTANCE, evt: HANDLE);
pub fn SetFileApisToANSI();
pub fn SetFileApisToOEM();
pub fn SetFileAttributesA(lpFileName: LPCSTR, dwFileAttributes: DWORD) -> BOOL;
pub fn SetFileAttributesTransactedA(
lpFileName: LPCSTR, dwFileAttributes: DWORD, hTransaction: HANDLE,
) -> BOOL;
pub fn SetFileAttributesTransactedW(
lpFileName: LPCWSTR, dwFileAttributes: DWORD, hTransaction: HANDLE,
) -> BOOL;
pub fn SetFileAttributesW(lpFileName: LPCWSTR, dwFileAttributes: DWORD) -> BOOL;
pub fn SetFileBandwidthReservation(
hFile: HANDLE, nPeriodMilliseconds: DWORD, nBytesPerPeriod: DWORD, bDiscardable: BOOL,
lpTransferSize: LPDWORD, lpNumOutstandingRequests: LPDWORD,
) -> BOOL;
pub fn SetFileCompletionNotificationModes(FileHandle: HANDLE, Flags: UCHAR) -> BOOL;
pub fn SetFileInformationByHandle(
hFile: HANDLE, FileInformationClass: FILE_INFO_BY_HANDLE_CLASS, lpFileInformation: LPVOID,
dwBufferSize: DWORD,
) -> BOOL;
pub fn SetFileIoOverlappedRange(
FileHandle: HANDLE, OverlappedRangeStart: PUCHAR, Length: ULONG,
) -> BOOL;
pub fn SetFilePointer(
hFile: HANDLE, lDistanceToMove: LONG, lpDistanceToMoveHigh: PLONG, dwMoveMethod: DWORD,
) -> DWORD;
pub fn SetFilePointerEx(
hFile: HANDLE, liDistanceToMove: LARGE_INTEGER, lpNewFilePointer: PLARGE_INTEGER,
dwMoveMethod: DWORD,
) -> BOOL;
pub fn SetFileShortNameA(hFile: HANDLE, lpShortName: LPCSTR) -> BOOL;
pub fn SetFileShortNameW(hFile: HANDLE, lpShortName: LPCWSTR) -> BOOL;
pub fn SetFileTime(
hFile: HANDLE, lpCreationTime: *const FILETIME, lpLastAccessTime: *const FILETIME,
lpLastWriteTime: *const FILETIME,
) -> BOOL;
pub fn SetFileValidData(hFile: HANDLE, ValidDataLength: LONGLONG) -> BOOL;
pub fn SetFirmwareEnvironmentVariableA(
lpName: LPCSTR, lpGuid: LPCSTR, pValue: PVOID, nSize: DWORD,
) -> BOOL;
pub fn SetFirmwareEnvironmentVariableExA(
lpName: LPCSTR, lpGuid: LPCSTR, pValue: PVOID, nSize: DWORD, dwAttributes: DWORD,
) -> BOOL;
pub fn SetFirmwareEnvironmentVariableExW(
lpName: LPCWSTR, lpGuid: LPCWSTR, pValue: PVOID, nSize: DWORD, dwAttributes: DWORD,
) -> BOOL;
pub fn SetFirmwareEnvironmentVariableW(
lpName: LPCWSTR, lpGuid: LPCWSTR, pValue: PVOID, nSize: DWORD,
) -> BOOL;
pub fn SetHandleCount(uNumber: UINT) -> UINT;
pub fn SetHandleInformation(hObject: HANDLE, dwMask: DWORD, dwFlags: DWORD) -> BOOL;
pub fn SetInformationJobObject(
hJob: HANDLE, JobObjectInformationClass: JOBOBJECTINFOCLASS,
lpJobObjectInformation: LPVOID, cbJobObjectInformationLength: DWORD,
) -> BOOL;
pub fn SetLastError(dwErrCode: DWORD);
pub fn SetLocalTime(lpSystemTime: *const SYSTEMTIME) -> BOOL;
pub fn SetLocaleInfoA(Locale: LCID, LCType: LCTYPE, lpLCData: LPCSTR) -> BOOL;
pub fn SetLocaleInfoW(Locale: LCID, LCType: LCTYPE, lpLCData: LPCWSTR) -> BOOL;
pub fn SetMailslotInfo(hMailslot: HANDLE, lReadTimeout: DWORD) -> BOOL;
pub fn SetMessageWaitingIndicator(hMsgIndicator: HANDLE, ulMsgCount: ULONG) -> BOOL;
pub fn SetNamedPipeAttribute(
Pipe: HANDLE, AttributeType: PIPE_ATTRIBUTE_TYPE, AttributeName: PSTR,
AttributeValue: PVOID, AttributeValueLength: SIZE_T,
) -> BOOL;
pub fn SetNamedPipeHandleState(
hNamedPipe: HANDLE, lpMode: LPDWORD, lpMaxCollectionCount: LPDWORD,
lpCollectDataTimeout: LPDWORD,
) -> BOOL;
pub fn SetPriorityClass(hProcess: HANDLE, dwPriorityClass: DWORD);
pub fn SetProcessAffinityMask(hProcess: HANDLE, dwProcessAffinityMask: DWORD) -> BOOL;
pub fn SetProcessAffinityUpdateMode(hProcess: HANDLE, dwFlags: DWORD) -> BOOL;
pub fn SetProcessDEPPolicy(dwFlags: DWORD) -> BOOL;
pub fn SetProcessInformation(
hProcess: HANDLE, ProcessInformationClass: PROCESS_INFORMATION_CLASS,
ProcessInformation: LPVOID, ProcessInformationSize: DWORD,
) -> BOOL;
pub fn SetProcessMitigationPolicy(
MitigationPolicy: PROCESS_MITIGATION_POLICY, lpBuffer: PVOID, dwLength: SIZE_T,
) -> BOOL;
pub fn SetProcessPreferredUILanguages(
dwFlags: DWORD, pwszLanguagesBuffer: PCZZWSTR, pulNumLanguages: PULONG,
) -> BOOL;
pub fn SetProcessPriorityBoost(hProcess: HANDLE, bDisablePriorityBoost: BOOL) -> BOOL;
pub fn SetProcessShutdownParameters(dwLevel: DWORD, dwFlags: DWORD) -> BOOL;
pub fn SetProcessWorkingSetSize(
hProcess: HANDLE, dwMinimumWorkingSetSize: SIZE_T, dwMaximumWorkingSetSize: SIZE_T,
) -> BOOL;
pub fn SetProcessWorkingSetSizeEx(
hProcess: HANDLE, dwMinimumWorkingSetSize: SIZE_T, dwMaximumWorkingSetSize: SIZE_T,
Flags: DWORD,
) -> BOOL;
pub fn SetProtectedPolicy(
PolicyGuid: LPCGUID, PolicyValue: ULONG_PTR, OldPolicyValue: PULONG_PTR,
) -> BOOL;
pub fn SetSearchPathMode(Flags: DWORD) -> BOOL;
pub fn SetStdHandle(nStdHandle: DWORD, hHandle: HANDLE) -> BOOL;
pub fn SetStdHandleEx(nStdHandle: DWORD, hHandle: HANDLE, phPrevValue: PHANDLE) -> BOOL;
pub fn SetSystemFileCacheSize(
MinimumFileCacheSize: SIZE_T, MaximumFileCacheSize: SIZE_T, Flags: DWORD,
) -> BOOL;
pub fn SetSystemPowerState(fSuspend: BOOL, fForce: BOOL) -> BOOL;
pub fn SetSystemTime(lpSystemTime: *const SYSTEMTIME) -> BOOL;
pub fn SetSystemTimeAdjustment(dwTimeAdjustment: DWORD, bTimeAdjustmentDisabled: BOOL) -> BOOL;
pub fn SetTapeParameters(
hDevice: HANDLE, dwOperation: DWORD, lpTapeInformation: LPVOID,
) -> DWORD;
pub fn SetTapePosition(
hDevice: HANDLE, dwPositionMethod: DWORD, dwPartition: DWORD,
dwOffsetLow: DWORD, dwOffsetHigh: DWORD, bImmediate: BOOL
) -> DWORD;
pub fn SetThreadAffinityMask(hThread: HANDLE, dwThreadAffinityMask: DWORD) -> DWORD_PTR;
pub fn SetThreadContext(hThread: HANDLE, lpContext: *const CONTEXT) -> BOOL;
pub fn SetThreadErrorMode(dwNewMode: DWORD, lpOldMode: LPDWORD) -> BOOL;
pub fn SetThreadExecutionState(esFlags: EXECUTION_STATE) -> EXECUTION_STATE;
pub fn SetThreadGroupAffinity(
hThread: HANDLE, GroupAffinity: *const GROUP_AFFINITY,
PreviousGroupAffinity: PGROUP_AFFINITY,
) -> BOOL;
pub fn SetThreadIdealProcessor(hThread: HANDLE, dwIdealProcessor: DWORD) -> DWORD;
pub fn SetThreadIdealProcessorEx(
hThread: HANDLE, lpIdealProcessor: PPROCESSOR_NUMBER,
lpPreviousIdealProcessor: PPROCESSOR_NUMBER,
) -> BOOL;
pub fn SetThreadInformation(
hThread: HANDLE, ThreadInformationClass: THREAD_INFORMATION_CLASS,
ThreadInformation: LPVOID, ThreadInformationSize: DWORD,
);
pub fn SetThreadLocale(Locale: LCID) -> BOOL;
pub fn SetThreadPreferredUILanguages(
dwFlags: DWORD, pwszLanguagesBuffer: PCZZWSTR, pulNumLanguages: PULONG,
) -> BOOL;
pub fn SetThreadPriority(hThread: HANDLE, nPriority: c_int) -> BOOL;
pub fn SetThreadPriorityBoost(hThread: HANDLE, bDisablePriorityBoost: BOOL) -> BOOL;
pub fn SetThreadStackGuarantee(StackSizeInBytes: PULONG) -> BOOL;
pub fn SetThreadUILanguage(LangId: LANGID) -> LANGID;
pub fn SetThreadpoolStackInformation(
ptpp: PTP_POOL, ptpsi: PTP_POOL_STACK_INFORMATION,
) -> BOOL;
pub fn SetThreadpoolThreadMaximum(ptpp: PTP_POOL, cthrdMost: DWORD);
pub fn SetThreadpoolThreadMinimum(ptpp: PTP_POOL, cthrdMic: DWORD);
pub fn SetThreadpoolTimer(
pti: PTP_TIMER, pftDueTime: PFILETIME, msPeriod: DWORD, msWindowLength: DWORD,
);
pub fn SetThreadpoolTimerEx(
pti: PTP_TIMER, pftDueTime: PFILETIME, msPeriod: DWORD, msWindowLength: DWORD,
) -> BOOL;
pub fn SetThreadpoolWait(pwa: PTP_WAIT, h: HANDLE, pftTimeout: PFILETIME);
pub fn SetThreadpoolWaitEx(
pwa: PTP_WAIT, h: HANDLE, pftTimeout: PFILETIME, Reserved: PVOID,
) -> BOOL;
pub fn SetTimeZoneInformation(lpTimeZoneInformation: *const TIME_ZONE_INFORMATION) -> BOOL;
pub fn SetTimerQueueTimer(
TimerQueue: HANDLE, Callback: WAITORTIMERCALLBACK, Parameter: PVOID, DueTime: DWORD,
Period: DWORD, PreferIo: BOOL,
) -> HANDLE;
#[cfg(target_arch = "x86_64")]
pub fn SetUmsThreadInformation(
UmsThread: PUMS_CONTEXT, UmsThreadInfoClass: UMS_THREAD_INFO_CLASS,
UmsThreadInformation: PVOID, UmsThreadInformationLength: ULONG,
) -> BOOL;
pub fn SetUnhandledExceptionFilter(
lpTopLevelExceptionFilter: LPTOP_LEVEL_EXCEPTION_FILTER,
) -> LPTOP_LEVEL_EXCEPTION_FILTER;
pub fn SetUserGeoID(GeoId: GEOID) -> BOOL;
pub fn SetVolumeLabelA(lpRootPathName: LPCSTR, lpVolumeName: LPCSTR) -> BOOL;
pub fn SetVolumeLabelW(lpRootPathName: LPCWSTR, lpVolumeName: LPCWSTR) -> BOOL;
pub fn SetVolumeMountPointA(lpszVolumeMountPoint: LPCSTR, lpszVolumeName: LPCSTR) -> BOOL;
pub fn SetVolumeMountPointW(lpszVolumeMountPoint: LPCWSTR, lpszVolumeName: LPCWSTR) -> BOOL;
pub fn SetWaitableTimer(
hTimer: HANDLE, lpDueTime: *const LARGE_INTEGER, lPeriod: LONG,
pfnCompletionRoutine: PTIMERAPCROUTINE, lpArgToCompletionRoutine: LPVOID, fResume: BOOL,
) -> BOOL;
pub fn SetWaitableTimerEx(
hTimer: HANDLE, lpDueTime: *const LARGE_INTEGER, lPeriod: LONG,
pfnCompletionRoutine: PTIMERAPCROUTINE, lpArgToCompletionRoutine: LPVOID,
WakeContext: PREASON_CONTEXT, TolerableDelay: ULONG,
) -> BOOL;
#[cfg(any(target_arch = "x86", target_arch = "x86_64"))]
pub fn SetXStateFeaturesMask(Context: PCONTEXT, FeatureMask: DWORD64) -> BOOL;
pub fn SetupComm(hFile: HANDLE, dwInQueue: DWORD, dwOutQueue: DWORD) -> BOOL;
pub fn SignalObjectAndWait(
hObjectToSignal: HANDLE, hObjectToWaitOn: HANDLE, dwMilliseconds: DWORD, bAlertable: BOOL,
) -> DWORD;
pub fn SizeofResource(hModule: HMODULE, hResInfo: HRSRC) -> DWORD;
pub fn Sleep(dwMilliseconds: DWORD);
pub fn SleepConditionVariableCS(
ConditionVariable: PCONDITION_VARIABLE, CriticalSection: PCRITICAL_SECTION,
dwMilliseconds: DWORD,
) -> BOOL;
pub fn SleepConditionVariableSRW(
ConditionVariable: PCONDITION_VARIABLE, SRWLock: PSRWLOCK, dwMilliseconds: DWORD,
Flags: ULONG,
) -> BOOL;
pub fn SleepEx(dwMilliseconds: DWORD, bAlertable: BOOL) -> DWORD;
pub fn StartThreadpoolIo(pio: PTP_IO);
pub fn SubmitThreadpoolWork(pwk: PTP_WORK);
pub fn SuspendThread(hThread: HANDLE) -> DWORD;
pub fn SwitchToFiber(lpFiber: LPVOID);
pub fn SwitchToThread() -> BOOL;
pub fn SystemTimeToFileTime(lpSystemTime: *const SYSTEMTIME, lpFileTime: LPFILETIME) -> BOOL;
pub fn SystemTimeToTzSpecificLocalTime(
lpTimeZoneInformation: *const TIME_ZONE_INFORMATION, lpUniversalTime: *const SYSTEMTIME,
lpLocalTime: LPSYSTEMTIME,
) -> BOOL;
pub fn SystemTimeToTzSpecificLocalTimeEx(
lpTimeZoneInformation: *const DYNAMIC_TIME_ZONE_INFORMATION,
lpUniversalTime: *const SYSTEMTIME, lpLocalTime: LPSYSTEMTIME,
) -> BOOL;
pub fn TerminateJobObject(hJob: HANDLE, uExitCode: UINT) -> BOOL;
pub fn TerminateProcess(hProcess: HANDLE, uExitCode: UINT) -> BOOL;
pub fn TerminateThread(hThread: HANDLE, dwExitCode: DWORD) -> BOOL;
pub fn Thread32First(hSnapshot: HANDLE, lpte: LPTHREADENTRY32) -> BOOL;
pub fn Thread32Next(hSnapshot: HANDLE, lpte: LPTHREADENTRY32) -> BOOL;
pub fn TlsAlloc() -> DWORD;
pub fn TlsFree(dwTlsIndex: DWORD) -> BOOL;
pub fn TlsGetValue(dwTlsIndex: DWORD) -> LPVOID;
pub fn TlsSetValue(dwTlsIndex: DWORD, lpTlsValue: LPVOID) -> BOOL;
pub fn Toolhelp32ReadProcessMemory(th32ProcessID: DWORD, lpBaseAddress: LPCVOID,
lpBuffer: LPVOID, cbRead: SIZE_T, lpNumberOfBytesRead: *mut SIZE_T
) -> BOOL;
pub fn TransactNamedPipe(
hNamedPipe: HANDLE, lpInBuffer: LPVOID, nInBufferSize: DWORD, lpOutBuffer: LPVOID,
nOutBufferSize: DWORD, lpBytesRead: LPDWORD, lpOverlapped: LPOVERLAPPED,
) -> BOOL;
pub fn TransmitCommChar(hFile: HANDLE, cChar: c_char) -> BOOL;
pub fn TryAcquireSRWLockExclusive(SRWLock: PSRWLOCK) -> BOOLEAN;
pub fn TryAcquireSRWLockShared(SRWLock: PSRWLOCK) -> BOOLEAN;
pub fn TryEnterCriticalSection(lpCriticalSection: LPCRITICAL_SECTION) -> BOOL;
pub fn TrySubmitThreadpoolCallback(
pfns: PTP_SIMPLE_CALLBACK, pv: PVOID, pcbe: PTP_CALLBACK_ENVIRON,
) -> BOOL;
pub fn TzSpecificLocalTimeToSystemTime(
lpTimeZoneInformation: *const TIME_ZONE_INFORMATION, lpLocalTime: *const SYSTEMTIME,
lpUniversalTime: LPSYSTEMTIME,
) -> BOOL;
pub fn TzSpecificLocalTimeToSystemTimeEx(
lpTimeZoneInformation: *const DYNAMIC_TIME_ZONE_INFORMATION,
lpLocalTime: *const SYSTEMTIME, lpUniversalTime: LPSYSTEMTIME,
) -> BOOL;
#[cfg(target_arch = "x86_64")]
pub fn UmsThreadYield(SchedulerParam: PVOID) -> BOOL;
pub fn UnhandledExceptionFilter(ExceptionInfo: *mut EXCEPTION_POINTERS) -> LONG;
pub fn UnlockFile(
hFile: HANDLE, dwFileOffsetLow: DWORD, dwFileOffsetHigh: DWORD,
nNumberOfBytesToUnlockLow: DWORD, nNumberOfBytesToUnlockHigh: DWORD,
) -> BOOL;
pub fn UnlockFileEx(
hFile: HANDLE, dwReserved: DWORD, nNumberOfBytesToUnlockLow: DWORD,
nNumberOfBytesToUnlockHigh: DWORD, lpOverlapped: LPOVERLAPPED,
) -> BOOL;
pub fn UnmapViewOfFile(lpBaseAddress: LPCVOID) -> BOOL;
pub fn UnregisterApplicationRecoveryCallback() -> HRESULT;
pub fn UnregisterApplicationRestart() -> HRESULT;
pub fn UnregisterBadMemoryNotification(RegistrationHandle: PVOID) -> BOOL;
pub fn UnregisterWait(WaitHandle: HANDLE) -> BOOL;
pub fn UnregisterWaitEx(WaitHandle: HANDLE, CompletionEvent: HANDLE) -> BOOL;
pub fn UpdateProcThreadAttribute(
lpAttributeList: LPPROC_THREAD_ATTRIBUTE_LIST, dwFlags: DWORD, Attribute: DWORD_PTR,
lpValue: PVOID, cbSize: SIZE_T, lpPreviousValue: PVOID, lpReturnSize: PSIZE_T,
) -> BOOL;
pub fn UpdateResourceA(
hUpdate: HANDLE, lpType: LPCSTR, lpName: LPCSTR, wLanguage: WORD, lpData: LPVOID, cb: DWORD,
) -> BOOL;
pub fn UpdateResourceW(
hUpdate: HANDLE, lpType: LPCWSTR, lpName: LPCWSTR, wLanguage: WORD, lpData: LPVOID,
cb: DWORD,
) -> BOOL;
pub fn VerLanguageNameA(wLang: DWORD, szLang: LPSTR, cchLang: DWORD) -> DWORD;
pub fn VerLanguageNameW(wLang: DWORD, szLang: LPWSTR, cchLang: DWORD) -> DWORD;
pub fn VerSetConditionMask(
ConditionMask: ULONGLONG, TypeMask: DWORD, Condition: BYTE,
) -> ULONGLONG;
pub fn VerifyScripts(
dwFlags: DWORD, lpLocaleScripts: LPCWSTR, cchLocaleScripts: c_int, lpTestScripts: LPCWSTR,
cchTestScripts: c_int,
) -> BOOL;
pub fn VerifyVersionInfoA(
lpVersionInformation: LPOSVERSIONINFOEXA, dwTypeMask: DWORD, dwlConditionMask: DWORDLONG,
) -> BOOL;
pub fn VerifyVersionInfoW(
lpVersionInformation: LPOSVERSIONINFOEXW, dwTypeMask: DWORD, dwlConditionMask: DWORDLONG,
) -> BOOL;
pub fn VirtualAlloc(
lpAddress: LPVOID, dwSize: SIZE_T, flAllocationType: DWORD, flProtect: DWORD,
) -> LPVOID;
pub fn VirtualAllocEx(
hProcess: HANDLE, lpAddress: LPVOID, dwSize: SIZE_T, flAllocationType: DWORD,
flProtect: DWORD,
) -> LPVOID;
pub fn VirtualAllocExNuma(
hProcess: HANDLE, lpAddress: LPVOID, dwSize: SIZE_T, flAllocationType: DWORD,
flProtect: DWORD, nndPreferred: DWORD,
) -> LPVOID;
pub fn VirtualFree(lpAddress: LPVOID, dwSize: SIZE_T, dwFreeType: DWORD) -> BOOL;
pub fn VirtualFreeEx(
hProcess: HANDLE, lpAddress: LPVOID, dwSize: SIZE_T, dwFreeType: DWORD,
) -> BOOL;
pub fn VirtualLock(lpAddress: LPVOID, dwSize: SIZE_T) -> BOOL;
pub fn VirtualProtect(
lpAddress: LPVOID, dwSize: SIZE_T, flNewProtect: DWORD, lpflOldProtect: DWORD,
) -> BOOL;
pub fn VirtualProtectEx(
hProcess: HANDLE, lpAddress: LPVOID, dwSize: SIZE_T, flNewProtect: DWORD,
lpflOldProtect: DWORD,
) -> BOOL;
pub fn VirtualQuery(
lpAddress: LPCVOID, lpBuffer: PMEMORY_BASIC_INFORMATION, dwLength: SIZE_T,
) -> SIZE_T;
pub fn VirtualQueryEx(
hProcess: HANDLE, lpAddress: LPCVOID, lpBuffer: PMEMORY_BASIC_INFORMATION, dwLength: SIZE_T,
) -> SIZE_T;
pub fn VirtualUnlock(lpAddress: LPVOID, dwSize: SIZE_T) -> BOOL;
pub fn WTSGetActiveConsoleSessionId() -> DWORD;
pub fn WaitCommEvent(hFile: HANDLE, lpEvtMask: LPDWORD, lpOverlapped: LPOVERLAPPED) -> BOOL;
pub fn WaitForDebugEvent(lpDebugEvent: LPDEBUG_EVENT, dwMilliseconds: DWORD) -> BOOL;
pub fn WaitForMultipleObjects(
nCount: DWORD, lpHandles: *const HANDLE, bWaitAll: BOOL, dwMilliseconds: DWORD,
) -> DWORD;
pub fn WaitForMultipleObjectsEx(
nCount: DWORD, lpHandles: *const HANDLE, bWaitAll: BOOL, dwMilliseconds: DWORD,
bAlertable: BOOL,
) -> DWORD;
pub fn WaitForSingleObject(hHandle: HANDLE, dwMilliseconds: DWORD) -> DWORD;
pub fn WaitForSingleObjectEx(
hHandle: HANDLE, dwMilliseconds: DWORD, bAlertable: BOOL,
) -> DWORD;
pub fn WaitForThreadpoolIoCallbacks(pio: PTP_IO, fCancelPendingCallbacks: BOOL);
pub fn WaitForThreadpoolTimerCallbacks(pti: PTP_TIMER, fCancelPendingCallbacks: BOOL);
pub fn WaitForThreadpoolWaitCallbacks(pwa: PTP_WAIT, fCancelPendingCallbacks: BOOL);
pub fn WaitForThreadpoolWorkCallbacks(pwk: PTP_WORK, fCancelPendingCallbacks: BOOL);
pub fn WaitNamedPipeA(lpNamedPipeName: LPCSTR, nTimeOut: DWORD) -> BOOL;
pub fn WaitNamedPipeW(lpNamedPipeName: LPCWSTR, nTimeOut: DWORD) -> BOOL;
pub fn WakeAllConditionVariable(ConditionVariable: PCONDITION_VARIABLE);
pub fn WakeConditionVariable(ConditionVariable: PCONDITION_VARIABLE);
pub fn WerGetFlags(hProcess: HANDLE, pdwFlags: PDWORD) -> HRESULT;
pub fn WerRegisterFile(
pwzFile: PCWSTR, regFileType: WER_REGISTER_FILE_TYPE, dwFlags: DWORD,
) -> HRESULT;
pub fn WerRegisterMemoryBlock(pvAddress: PVOID, dwSize: DWORD) -> HRESULT;
pub fn WerRegisterRuntimeExceptionModule(
pwszOutOfProcessCallbackDll: PCWSTR, pContext: PVOID,
) -> HRESULT;
pub fn WerSetFlags(dwFlags: DWORD) -> HRESULT;
pub fn WerUnregisterFile(pwzFilePath: PCWSTR) -> HRESULT;
pub fn WerUnregisterMemoryBlock(pvAddress: PVOID) -> HRESULT;
pub fn WerUnregisterRuntimeExceptionModule(
pwszOutOfProcessCallbackDll: PCWSTR, pContext: PVOID,
) -> HRESULT;
pub fn WideCharToMultiByte(
CodePage: UINT, dwFlags: DWORD, lpWideCharStr: LPCWCH, cchWideChar: c_int,
lpMultiByteStr: LPSTR, cbMultiByte: c_int, lpDefaultChar: LPCCH, lpUsedDefaultChar: LPBOOL,
) -> c_int;
pub fn WinExec(lpCmdLine: LPCSTR, uCmdShow: UINT) -> UINT;
pub fn Wow64DisableWow64FsRedirection(OldValue: *mut PVOID) -> BOOL;
pub fn Wow64EnableWow64FsRedirection(Wow64FsEnableRedirection: BOOLEAN) -> BOOLEAN;
pub fn Wow64GetThreadContext(hThread: HANDLE, lpContext: PWOW64_CONTEXT) -> BOOL;
pub fn Wow64GetThreadSelectorEntry(
hThread: HANDLE, dwSelector: DWORD, lpSelectorEntry: PWOW64_LDT_ENTRY,
) -> BOOL;
pub fn Wow64RevertWow64FsRedirection(OlValue: PVOID) -> BOOL;
pub fn Wow64SetThreadContext(hThread: HANDLE, lpContext: *const WOW64_CONTEXT) -> BOOL;
pub fn Wow64SuspendThread(hThread: HANDLE) -> DWORD;
pub fn WriteConsoleA(
hConsoleOutput: HANDLE, lpBuffer: *const VOID, nNumberOfCharsToWrite: DWORD,
lpNumberOfCharsWritten: LPDWORD, lpReserved: LPVOID,
) -> BOOL;
pub fn WriteConsoleInputA(
hConsoleInput: HANDLE, lpBuffer: *const INPUT_RECORD, nLength: DWORD,
lpNumberOfEventsWritten: LPDWORD,
) -> BOOL;
pub fn WriteConsoleInputW(
hConsoleInput: HANDLE, lpBuffer: *const INPUT_RECORD, nLength: DWORD,
lpNumberOfEventsWritten: LPDWORD,
) -> BOOL;
pub fn WriteConsoleOutputA(
hConsoleOutput: HANDLE, lpBuffer: *const CHAR_INFO, dwBufferSize: COORD,
dwBufferCoord: COORD, lpWriteRegion: PSMALL_RECT,
) -> BOOL;
pub fn WriteConsoleOutputAttribute(
hConsoleOutput: HANDLE, lpAttribute: *const WORD, nLength: DWORD, dwWriteCoord: COORD,
lpNumberOfAttrsWritten: LPDWORD,
) -> BOOL;
pub fn WriteConsoleOutputCharacterA(
hConsoleOutput: HANDLE, lpCharacter: LPCSTR, nLength: DWORD, dwWriteCoord: COORD,
lpNumberOfCharsWritten: LPDWORD,
) -> BOOL;
pub fn WriteConsoleOutputCharacterW(
hConsoleOutput: HANDLE, lpCharacter: LPCWSTR, nLength: DWORD, dwWriteCoord: COORD,
lpNumberOfCharsWritten: LPDWORD,
) -> BOOL;
pub fn WriteConsoleOutputW(
hConsoleOutput: HANDLE, lpBuffer: *const CHAR_INFO, dwBufferSize: COORD,
dwBufferCoord: COORD, lpWriteRegion: PSMALL_RECT,
) -> BOOL;
pub fn WriteConsoleW(
hConsoleOutput: HANDLE, lpBuffer: *const VOID, nNumberOfCharsToWrite: DWORD,
lpNumberOfCharsWritten: LPDWORD, lpReserved: LPVOID,
) -> BOOL;
pub fn WriteFile(
hFile: HANDLE, lpBuffer: LPCVOID, nNumberOfBytesToWrite: DWORD,
lpNumberOfBytesWritten: LPDWORD, lpOverlapped: LPOVERLAPPED,
) -> BOOL;
pub fn WriteFileEx(
hFile: HANDLE, lpBuffer: LPCVOID, nNumberOfBytesToWrite: DWORD, lpOverlapped: LPOVERLAPPED,
lpCompletionRoutine: LPOVERLAPPED_COMPLETION_ROUTINE,
) -> BOOL;
pub fn WriteFileGather(
hFile: HANDLE, aSegmentArray: *mut FILE_SEGMENT_ELEMENT, nNumberOfBytesToWrite: DWORD,
lpReserved: LPDWORD, lpOverlapped: LPOVERLAPPED,
) -> BOOL;
pub fn WritePrivateProfileSectionA(
lpAppName: LPCSTR, lpString: LPCSTR, lpFileName: LPCSTR,
) -> BOOL;
pub fn WritePrivateProfileSectionW(
lpAppName: LPCWSTR, lpString: LPCWSTR, lpFileName: LPCWSTR,
) -> BOOL;
pub fn WritePrivateProfileStringA(
lpAppName: LPCSTR, lpKeyName: LPCSTR, lpString: LPCSTR, lpFileName: LPCSTR,
) -> BOOL;
pub fn WritePrivateProfileStringW(
lpAppName: LPCWSTR, lpKeyName: LPCWSTR, lpString: LPCWSTR, lpFileName: LPCWSTR,
) -> BOOL;
pub fn WritePrivateProfileStructA(
lpszSection: LPCSTR, lpszKey: LPCSTR, lpStruct: LPVOID, uSizeStruct: UINT, szFile: LPCSTR,
) -> BOOL;
pub fn WritePrivateProfileStructW(
lpszSection: LPCWSTR, lpszKey: LPCWSTR, lpStruct: LPVOID, uSizeStruct: UINT,
szFile: LPCWSTR,
) -> BOOL;
pub fn WriteProcessMemory(
hProcess: HANDLE, lpBaseAddress: LPVOID, lpBuffer: LPCVOID, nSize: SIZE_T,
lpNumberOfBytesWritten: *mut SIZE_T,
) -> BOOL;
pub fn WriteProfileSectionA(lpAppName: LPCSTR, lpString: LPCSTR) -> BOOL;
pub fn WriteProfileSectionW(lpAppName: LPCWSTR, lpString: LPCWSTR) -> BOOL;
pub fn WriteProfileStringA(lpAppName: LPCSTR, lpKeyName: LPCSTR, lpString: LPCSTR) -> BOOL;
pub fn WriteProfileStringW(lpAppName: LPCWSTR, lpKeyName: LPCWSTR, lpString: LPCWSTR) -> BOOL;
pub fn WriteTapemark(
hDevice: HANDLE, dwTapemarkType: DWORD, dwTapemarkCount: DWORD, bImmediate: BOOL,
) -> DWORD;
pub fn ZombifyActCtx(hActCtx: HANDLE) -> BOOL;
pub fn _hread(hFile: HFILE, lpBuffer: LPVOID, lBytes: c_long) -> c_long;
pub fn _hwrite(hFile: HFILE, lpBuffer: LPCCH, lBytes: c_long) -> c_long;
pub fn _lclose(hFile: HFILE) -> HFILE;
pub fn _lcreat(lpPathName: LPCSTR, iAttrubute: c_int) -> HFILE;
pub fn _llseek(hFile: HFILE, lOffset: LONG, iOrigin: c_int) -> LONG;
pub fn _lopen(lpPathName: LPCSTR, iReadWrite: c_int) -> HFILE;
pub fn _lread(hFile: HFILE, lpBuffer: LPVOID, uBytes: UINT) -> UINT;
pub fn _lwrite(hFile: HFILE, lpBuffer: LPCCH, uBytes: UINT) -> UINT;
pub fn lstrcat(lpString1: LPSTR, lpString2: LPCSTR) -> LPSTR;
pub fn lstrcatA(lpString1: LPSTR, lpString2: LPCSTR) -> LPSTR;
pub fn lstrcatW(lpString1: LPWSTR, lpString2: LPCWSTR) -> LPSTR;
pub fn lstrcmp(lpString1: LPCSTR, lpString2: LPCSTR) -> c_int;
pub fn lstrcmpA(lpString1: LPCSTR, lpString2: LPCSTR) -> c_int;
pub fn lstrcmpW(lpString1: LPCWSTR, lpString2: LPCWSTR) -> c_int;
pub fn lstrcmpi(lpString1: LPCSTR, lpString2: LPCSTR) -> c_int;
pub fn lstrcmpiA(lpString1: LPCSTR, lpString2: LPCSTR) -> c_int;
pub fn lstrcmpiW(lpString1: LPCWSTR, lpString2: LPCWSTR) -> c_int;
pub fn lstrcpy(lpString1: LPSTR, lpString2: LPCSTR) -> LPSTR;
pub fn lstrcpyA(lpString1: LPSTR, lpString2: LPCSTR) -> LPSTR;
pub fn lstrcpyW(lpString1: LPWSTR, lpString2: LPCWSTR) -> LPSTR;
pub fn lstrcpyn(lpString1: LPSTR, lpString2: LPCSTR, iMaxLength: c_int) -> LPSTR;
pub fn lstrcpynA(lpString1: LPSTR, lpString2: LPCSTR, iMaxLength: c_int) -> LPSTR;
pub fn lstrcpynW(lpString1: LPWSTR, lpString2: LPCWSTR, iMaxLength: c_int) -> LPSTR;
pub fn lstrlen(lpString: LPCSTR) -> c_int;
pub fn lstrlenA(lpString: LPCSTR) -> c_int;
pub fn lstrlenW(lpString: LPCWSTR) -> c_int;
#[cfg(any(target_arch = "arm", target_arch = "x86_64"))]
pub fn uaw_lstrcmpW(String1: PCUWSTR, String2: PCUWSTR) -> c_int;
#[cfg(any(target_arch = "arm", target_arch = "x86_64"))]
pub fn uaw_lstrcmpiW(String1: PCUWSTR, String2: PCUWSTR) -> c_int;
#[cfg(any(target_arch = "arm", target_arch = "x86_64"))]
pub fn uaw_lstrlenW(String: LPCUWSTR) -> c_int;
#[cfg(any(target_arch = "arm", target_arch = "x86_64"))]
pub fn uaw_wcschr(String: PCUWSTR, Character: WCHAR) -> PUWSTR;
#[cfg(any(target_arch = "arm", target_arch = "x86_64"))]
pub fn uaw_wcscpy(Destination: PUWSTR, Source: PCUWSTR) -> PUWSTR;
#[cfg(any(target_arch = "arm", target_arch = "x86_64"))]
pub fn uaw_wcsicmp(String1: PCUWSTR, String2: PCUWSTR) -> c_int;
#[cfg(any(target_arch = "arm", target_arch = "x86_64"))]
pub fn uaw_wcslen(String: PCUWSTR) -> size_t;
#[cfg(any(target_arch = "arm", target_arch = "x86_64"))]
pub fn uaw_wcsrchr(String: PCUWSTR, Character: WCHAR) -> PUWSTR;
}