/// An application-defined callback function used with the <c>CopyFileEx</c>, <c>MoveFileTransacted</c>, and <c>MoveFileWithProgress</c> functions. It is
/// called when a portion of a copy or move operation is completed. The <c>LPPROGRESS_ROUTINE</c> type defines a pointer to this callback function.
/// <c>CopyProgressRoutine</c> is a placeholder for the application-defined function name.
/// </summary>
/// <param name="TotalFileSize">The total size of the file, in bytes.</param>
/// <param name="TotalBytesTransferred">
/// The total number of bytes transferred from the source file to the destination file since the copy operation began.
/// </param>
/// <param name="StreamSize">The total size of the current file stream, in bytes.</param>
/// <param name="StreamBytesTransferred">
/// The total number of bytes in the current stream that have been transferred from the source file to the destination file since the copy operation began.
/// </param>
/// <param name="dwStreamNumber">A handle to the current stream. The first time <c>CopyProgressRoutine</c> is called, the stream number is 1.</param>
/// <param name="dwCallbackReason">
/// <para>The reason that <c>CopyProgressRoutine</c> was called. This parameter can be one of the following values.</para>
/// <term>Another part of the data file was copied.</term>
/// </item>
/// <item>
/// <term>CALLBACK_STREAM_SWITCH0x00000001</term>
/// <term>Another stream was created and is about to be copied. This is the callback reason given when the callback routine is first invoked.</term>
/// </item>
/// </list>
/// </para>
/// </param>
/// <param name="hSourceFile">A handle to the source file.</param>
/// <param name="hDestinationFile">A handle to the destination file</param>
/// <param name="lpData">Argument passed to <c>CopyProgressRoutine</c> by <c>CopyFileEx</c>, <c>MoveFileTransacted</c>, or <c>MoveFileWithProgress</c>.</param>
/// <returns>
/// <para>The <c>CopyProgressRoutine</c> function should return one of the following values.</para>
/// <para>
/// <list type="table">
/// <listheader>
/// <term>Return code/value</term>
/// <term>Description</term>
/// </listheader>
/// <item>
/// <term>PROGRESS_CANCEL1</term>
/// <term>Cancel the copy operation and delete the destination file.</term>
/// </item>
/// <item>
/// <term>PROGRESS_CONTINUE0</term>
/// <term>Continue the copy operation.</term>
/// </item>
/// <item>
/// <term>PROGRESS_QUIET3</term>
/// <term>Continue the copy operation, but stop invoking CopyProgressRoutine to report progress.</term>
/// </item>
/// <item>
/// <term>PROGRESS_STOP2</term>
/// <term>Stop the copy operation. It can be restarted at a later time.</term>
/// <summary>The reason that CopyProgressRoutine was called.</summary>
publicenumCOPY_CALLBACK_REASON:uint
{
/// <summary>Another part of the data file was copied.</summary>
CALLBACK_CHUNK_FINISHED=0x00000000,
/// <summary>Another stream was created and is about to be copied. This is the callback reason given when the callback routine is first invoked.</summary>
/// <para>Minimal information for the file should be retrieved or set. Used for file handles. See <c>FILE_BASIC_INFO</c>.</para>
/// </summary>
FileBasicInfo=0,
/// <summary>
/// <para>
/// Extended information for the file should be retrieved. Used for file handles. Use only when calling <c>GetFileInformationByHandleEx</c>. See <c>FILE_STANDARD_INFO</c>.
/// </para>
/// </summary>
FileStandardInfo,
/// <summary>
/// <para>The file name should be retrieved. Used for any handles. Use only when calling <c>GetFileInformationByHandleEx</c>. See <c>FILE_NAME_INFO</c>.</para>
/// </summary>
FileNameInfo,
/// <summary>
/// <para>The file name should be changed. Used for file handles. Use only when calling <c>SetFileInformationByHandle</c>. See <c>FILE_RENAME_INFO</c>.</para>
/// </summary>
FileRenameInfo,
/// <summary>
/// <para>The file should be deleted. Used for any handles. Use only when calling <c>SetFileInformationByHandle</c>. See <c>FILE_DISPOSITION_INFO</c>.</para>
/// </summary>
FileDispositionInfo,
/// <summary>
/// <para>
/// The file allocation information should be changed. Used for file handles. Use only when calling <c>SetFileInformationByHandle</c>. See <c>FILE
/// ALLOCATION INFO</c>.
/// </para>
/// </summary>
FileAllocationInfo,
/// <summary>
/// <para>The end of the file should be set. Use only when calling <c>SetFileInformationByHandle</c>. See <c>FILE_END_OF_FILE_INFO</c>.</para>
/// </summary>
FileEndOfFileInfo,
/// <summary>
/// <para>
/// File stream information for the specified file should be retrieved. Used for any handles. Use only when calling
/// <c>GetFileInformationByHandleEx</c>. See <c>FILE_STREAM_INFO</c>.
/// </para>
/// </summary>
FileStreamInfo,
/// <summary>
/// <para>
/// File compression information should be retrieved. Used for any handles. Use only when calling <c>GetFileInformationByHandleEx</c>. See <c>FILE_COMPRESSION_INFO</c>.
/// </para>
/// </summary>
FileCompressionInfo,
/// <summary>
/// <para>File attribute information should be retrieved. Used for any handles. Use only when calling <c>GetFileInformationByHandleEx</c>. See <c>FILE_ATTRIBUTE_TAG_INFO</c>.</para>
/// </summary>
FileAttributeTagInfo,
/// <summary>
/// <para>
/// Files in the specified directory should be retrieved. Used for directory handles. Use only when calling <c>GetFileInformationByHandleEx</c>. The
/// number of files returned for each call to <c>GetFileInformationByHandleEx</c> depends on the size of the buffer that is passed to the function.
/// Any subsequent calls to <c>GetFileInformationByHandleEx</c> on the same handle will resume the enumeration operation after the last file is
/// returned. See <c>FILE_ID_BOTH_DIR_INFO</c>.
/// </para>
/// </summary>
FileIdBothDirectoryInfo,
/// <summary>
/// <para>Identical to <c>FileIdBothDirectoryInfo</c>, but forces the enumeration operation to start again from the beginning. See <c>FILE_ID_BOTH_DIR_INFO</c>.</para>
/// </summary>
FileIdBothDirectoryRestartInfo,
/// <summary>
/// <para>Priority hint information should be set. Use only when calling <c>SetFileInformationByHandle</c>. See <c>FILE_IO_PRIORITY_HINT_INFO</c>.</para>
/// </summary>
FileIoPriorityHintInfo,
/// <summary>
/// <para>
/// File remote protocol information should be retrieved. Use for any handles. Use only when calling <c>GetFileInformationByHandleEx</c>. See <c>FILE_REMOTE_PROTOCOL_INFO</c>.
/// </para>
/// </summary>
FileRemoteProtocolInfo,
/// <summary>
/// <para>
/// Files in the specified directory should be retrieved. Used for directory handles. Use only when calling <c>GetFileInformationByHandleEx</c>. See <c>FILE_FULL_DIR_INFO</c>.
/// </para>
/// <para>
/// <c>Windows Server 2008 R2, Windows 7, Windows Server 2008, Windows Vista, Windows Server 2003 and Windows XP:</c> This value is not supported
/// before Windows 8 and Windows Server 2012
/// </para>
/// </summary>
FileFullDirectoryInfo,
/// <summary>
/// <para>
/// Identical to <c>FileFullDirectoryInfo</c>, but forces the enumeration operation to start again from the beginning. Use only when calling
/// <c>GetFileInformationByHandleEx</c>. See <c>FILE_FULL_DIR_INFO</c>.
/// </para>
/// <para>
/// <c>Windows Server 2008 R2, Windows 7, Windows Server 2008, Windows Vista, Windows Server 2003 and Windows XP:</c> This value is not supported
/// before Windows 8 and Windows Server 2012
/// </para>
/// </summary>
FileFullDirectoryRestartInfo,
/// <summary>
/// <para>File storage information should be retrieved. Use for any handles. Use only when calling <c>GetFileInformationByHandleEx</c>. See <c>FILE_STORAGE_INFO</c>.</para>
/// <para>
/// <c>Windows Server 2008 R2, Windows 7, Windows Server 2008, Windows Vista, Windows Server 2003 and Windows XP:</c> This value is not supported
/// before Windows 8 and Windows Server 2012
/// </para>
/// </summary>
FileStorageInfo,
/// <summary>
/// <para>File alignment information should be retrieved. Use for any handles. Use only when calling <c>GetFileInformationByHandleEx</c>. See <c>FILE_ALIGNMENT_INFO</c>.</para>
/// <para>
/// <c>Windows Server 2008 R2, Windows 7, Windows Server 2008, Windows Vista, Windows Server 2003 and Windows XP:</c> This value is not supported
/// before Windows 8 and Windows Server 2012
/// </para>
/// </summary>
FileAlignmentInfo,
/// <summary>
/// <para>File information should be retrieved. Use for any handles. Use only when calling <c>GetFileInformationByHandleEx</c>. See <c>FILE_ID_INFO</c>.</para>
/// <para>
/// <c>Windows Server 2008 R2, Windows 7, Windows Server 2008, Windows Vista, Windows Server 2003 and Windows XP:</c> This value is not supported
/// before Windows 8 and Windows Server 2012
/// </para>
/// </summary>
FileIdInfo,
/// <summary>
/// <para>
/// Files in the specified directory should be retrieved. Used for directory handles. Use only when calling <c>GetFileInformationByHandleEx</c>. See <c>FILE_ID_EXTD_DIR_INFO</c>.
/// </para>
/// <para>
/// <c>Windows Server 2008 R2, Windows 7, Windows Server 2008, Windows Vista, Windows Server 2003 and Windows XP:</c> This value is not supported
/// before Windows 8 and Windows Server 2012
/// </para>
/// </summary>
FileIdExtdDirectoryInfo,
/// <summary>
/// <para>
/// Identical to <c>FileIdExtdDirectoryInfo</c>, but forces the enumeration operation to start again from the beginning. Use only when calling
/// <c>GetFileInformationByHandleEx</c>. See <c>FILE_ID_EXTD_DIR_INFO</c>.
/// </para>
/// <para>
/// <c>Windows Server 2008 R2, Windows 7, Windows Server 2008, Windows Vista, Windows Server 2003 and Windows XP:</c> This value is not supported
/// before Windows 8 and Windows Server 2012
/// </para>
/// </summary>
FileIdExtdDirectoryRestartInfo,
/// <summary>
/// <para>This value is used for validation. Supported values are less than this value.</para>
/// </summary>
MaximumFileInfoByHandlesClass,
}
/// <summary>The type of result to return.</summary>
[PInvokeData("WinBase.h")]
[Flags]
publicenumFinalPathNameOptions
{
/// <summary>Return the path with the drive letter. This is the default.</summary>
VOLUME_NAME_DOS=0x0,
/// <summary>Return the path with a volume GUID path instead of the drive name.</summary>
VOLUME_NAME_GUID=0x1,
/// <summary>Return the path with the volume device path.</summary>
VOLUME_NAME_NT=0x2,
/// <summary>Return the path with no drive information.</summary>
VOLUME_NAME_NONE=0x4,
/// <summary>Return the normalized drive name. This is the default.</summary>
FILE_NAME_NORMALIZED=0x0,
/// <summary>Return the opened file name (not normalized).</summary>
FILE_NAME_OPENED=0x8,
}
/// <summary>MoveFileEx options.</summary>
[Flags]
publicenumMOVEFILE:uint
{
/// <summary>
/// If a file named lpNewFileName exists, the function replaces its contents with the contents of the lpExistingFileName file, provided that security
/// requirements regarding access control lists (ACLs) are met. For more information, see the Remarks section of this topic.This value cannot be used
/// if lpNewFileName or lpExistingFileName names a directory.
/// </summary>
MOVEFILE_REPLACE_EXISTING=0x00000001,
/// <summary>
/// If the file is to be moved to a different volume, the function simulates the move by using the CopyFile and DeleteFile functions.If the file is
/// successfully copied to a different volume and the original file is unable to be deleted, the function succeeds leaving the source file
/// intact.This value cannot be used with MOVEFILE_DELAY_UNTIL_REBOOT.
/// </summary>
MOVEFILE_COPY_ALLOWED=0x00000002,
/// <summary>
/// The system does not move the file until the operating system is restarted. The system moves the file immediately after AUTOCHK is executed, but
/// before creating any paging files. Consequently, this parameter enables the function to delete paging files from previous startups.This value can
/// be used only if the process is in the context of a user who belongs to the administrators group or the LocalSystem account. This value cannot be
/// used with MOVEFILE_COPY_ALLOWED.Windows Server 2003 and Windows XP: For information about special situations where this functionality can fail,
/// and a suggested workaround solution, see Files are not exchanged when Windows Server 2003 restarts if you use the MoveFileEx function to schedule
/// a replacement for some files in the Help and Support Knowledge Base.
/// </summary>
MOVEFILE_DELAY_UNTIL_REBOOT=0x00000004,
/// <summary>
/// The function does not return until the file is actually moved on the disk.Setting this value guarantees that a move performed as a copy and
/// delete operation is flushed to disk before the function returns. The flush occurs at the end of the copy operation.This value has no effect if
/// MOVEFILE_DELAY_UNTIL_REBOOT is set.
/// </summary>
MOVEFILE_WRITE_THROUGH=0x00000008,
/// <summary>Reserved for future use.</summary>
MOVEFILE_CREATE_HARDLINK=0x00000010,
/// <summary>
/// The function fails if the source file is a link source, but the file cannot be tracked after the move. This situation can occur if the
/// destination is a volume formatted with the FAT file system.
/// </summary>
MOVEFILE_FAIL_IF_NOT_TRACKABLE=0x00000020
}
/// <summary>ReplaceFile options.</summary>
publicenumREPLACEFILE
{
/// <summary>This value is not supported.</summary>
REPLACEFILE_WRITE_THROUGH=0x00000001,
/// <summary>
/// Ignores errors that occur while merging information (such as attributes and ACLs) from the replaced file to the replacement file. Therefore, if
/// you specify this flag and do not have WRITE_DAC access, the function succeeds but the ACLs are not preserved.
/// </summary>
REPLACEFILE_IGNORE_MERGE_ERRORS=0x00000002,
/// <summary>
/// Ignores errors that occur while merging ACL information from the replaced file to the replacement file. Therefore, if you specify this flag and
/// do not have WRITE_DAC access, the function succeeds but the ACLs are not preserved. To compile an application that uses this value, define the
/// _WIN32_WINNT macro as 0x0600 or later.
/// <para>Windows Server 2003 and Windows XP: This value is not supported.</para>
/// </summary>
REPLACEFILE_IGNORE_ACL_ERRORS=0x00000004,
}
/// <summary>
/// <para>Defines values that are used with the <c>FindFirstStreamW</c> function to specify the information level of the returned data.</para>
/// <para>The <c>FindFirstStreamW</c> function retrieves standard stream information. The data is returned in a <c>WIN32_FIND_STREAM_DATA</c> structure.</para>
/// <summary>Determines whether the specified name can be used to create a file on a FAT file system.</summary>
/// <param name="lpName">The file name, in 8.3 format.</param>
/// <param name="lpOemName">A pointer to a buffer that receives the OEM string that corresponds to Name. This parameter can be <c>NULL</c>.</param>
/// <param name="OemNameSize">The size of the lpOemName buffer, in characters. If lpOemName is <c>NULL</c>, this parameter must be 0 (zero).</param>
/// <param name="pbNameContainsSpaces">
/// Indicates whether or not a name contains spaces. This parameter can be <c>NULL</c>. If the name is not a valid 8.3 FAT file system name, this
/// parameter is undefined.
/// </param>
/// <param name="pbNameLegal">
/// If the function succeeds, this parameter indicates whether a file name is a valid 8.3 FAT file name when the current OEM code page is applied to the
/// file name.
/// </param>
/// <returns>
/// <para>If the function succeeds, the return value is nonzero.</para>
/// <para>If the function fails, the return value is 0 (zero). To get extended error information, call <c>GetLastError</c>.</para>
/// <para>Copies an existing file to a new file.</para>
/// <para>
/// The <c>CopyFileEx</c> function provides two additional capabilities. <c>CopyFileEx</c> can call a specified callback function each time a portion of
/// the copy operation is completed, and <c>CopyFileEx</c> can be canceled during the copy operation.
/// </para>
/// <para>To perform this operation as a transacted operation, use the <c>CopyFileTransacted</c> function.</para>
/// </summary>
/// <param name="lpExistingFileName">
/// <para>The name of an existing file.</para>
/// <para>
/// In the ANSI version of this function, the name is limited to <c>MAX_PATH</c> characters. To extend this limit to 32,767 wide characters, call the
/// Unicode version of the function and prepend "\\?\" to the path. For more information, see Naming a File.
/// </para>
/// <para>If lpExistingFileName does not exist, <c>CopyFile</c> fails, and <c>GetLastError</c> returns <c>ERROR_FILE_NOT_FOUND</c>.</para>
/// </param>
/// <param name="lpNewFileName">
/// <para>The name of the new file.</para>
/// <para>
/// In the ANSI version of this function, the name is limited to <c>MAX_PATH</c> characters. To extend this limit to 32,767 wide characters, call the
/// Unicode version of the function and prepend "\\?\" to the path. For more information, see Naming a File.
/// </para>
/// </param>
/// <param name="bFailIfExists">
/// If this parameter is <c>TRUE</c> and the new file specified by lpNewFileName already exists, the function fails. If this parameter is <c>FALSE</c>
/// and the new file already exists, the function overwrites the existing file and succeeds.
/// </param>
/// <returns>
/// <para>If the function succeeds, the return value is nonzero.</para>
/// <para>If the function fails, the return value is zero. To get extended error information, call <c>GetLastError</c>.</para>
/// <para>Copies an existing file to a new file, notifying the application of its progress through a callback function.</para>
/// <para>To perform this operation as a transacted operation, use the <c>CopyFileTransacted</c> function.</para>
/// </summary>
/// <param name="lpExistingFileName">
/// <para>The name of an existing file.</para>
/// <para>
/// In the ANSI version of this function, the name is limited to <c>MAX_PATH</c> characters. To extend this limit to 32,767 wide characters, call the
/// Unicode version of the function and prepend "\\?\" to the path. For more information, see Naming a File.
/// </para>
/// <para>If lpExistingFileName does not exist, the <c>CopyFileEx</c> function fails, and the <c>GetLastError</c> function returns <c>ERROR_FILE_NOT_FOUND</c>.</para>
/// </param>
/// <param name="lpNewFileName">
/// <para>The name of the new file.</para>
/// <para>
/// In the ANSI version of this function, the name is limited to <c>MAX_PATH</c> characters. To extend this limit to 32,767 wide characters, call the
/// Unicode version of the function and prepend "\\?\" to the path. For more information, see Naming a File.
/// </para>
/// </param>
/// <param name="lpProgressRoutine">
/// The address of a callback function of type <c>LPPROGRESS_ROUTINE</c> that is called each time another portion of the file has been copied. This
/// parameter can be <c>NULL</c>. For more information on the progress callback function, see the <c>CopyProgressRoutine</c> function.
/// </param>
/// <param name="lpData">The argument to be passed to the callback function. This parameter can be <c>NULL</c>.</param>
/// <param name="pbCancel">
/// If this flag is set to <c>TRUE</c> during the copy operation, the operation is canceled. Otherwise, the copy operation will continue to completion.
/// </param>
/// <param name="dwCopyFlags">
/// <para>Flags that specify how the file is to be copied. This parameter can be a combination of the following values.</para>
/// <term>The copy operation fails immediately if the target file already exists.</term>
/// </item>
/// <item>
/// <term>COPY_FILE_NO_BUFFERING0x00001000</term>
/// <term>
/// The copy operation is performed using unbuffered I/O, bypassing system I/O cache resources. Recommended for very large file transfers. Windows Server
/// 2003 and Windows XP: This value is not supported.
/// <term>The file is copied and the original file is opened for write access.</term>
/// </item>
/// <item>
/// <term>COPY_FILE_RESTARTABLE0x00000002</term>
/// <term>
/// Progress of the copy is tracked in the target file in case the copy fails. The failed copy can be restarted at a later time by specifying the same
/// values for lpExistingFileName and lpNewFileName as those used in the call that failed. This can significantly slow down the copy operation as the new
/// file may be flushed multiple times during the copy operation.
/// </term>
/// </item>
/// </list>
/// </para>
/// </param>
/// <returns>
/// <para>If the function succeeds, the return value is nonzero.</para>
/// <para>If the function fails, the return value is zero. To get extended error information call <c>GetLastError</c>.</para>
/// <para>
/// If lpProgressRoutine returns <c>PROGRESS_CANCEL</c> due to the user canceling the operation, <c>CopyFileEx</c> will return zero and
/// <c>GetLastError</c> will return <c>ERROR_REQUEST_ABORTED</c>. In this case, the partially copied destination file is deleted.
/// </para>
/// <para>
/// If lpProgressRoutine returns <c>PROGRESS_STOP</c> due to the user stopping the operation, <c>CopyFileEx</c> will return zero and <c>GetLastError</c>
/// will return <c>ERROR_REQUEST_ABORTED</c>. In this case, the partially copied destination file is left intact.
/// Creates a new directory with the attributes of a specified template directory. If the underlying file system supports security on files and
/// directories, the function applies a specified security descriptor to the new directory. The new directory retains the other attributes of the
/// specified template directory.
/// </para>
/// <para>To perform this operation as a transacted operation, use the <c>CreateDirectoryTransacted</c> function.</para>
/// </summary>
/// <param name="lpTemplateDirectory">
/// <para>The path of the directory to use as a template when creating the new directory.</para>
/// <para>
/// In the ANSI version of this function, the name is limited to <c>MAX_PATH</c> characters. To extend this limit to 32,767 wide characters, call the
/// Unicode version of the function and prepend "\\?\" to the path. For more information, see Naming a File.
/// </para>
/// </param>
/// <param name="lpNewDirectory">
/// <para>The path of the directory to be created.</para>
/// <para>
/// In the ANSI version of this function, the name is limited to <c>MAX_PATH</c> characters. To extend this limit to 32,767 wide characters, call the
/// Unicode version of the function and prepend "\\?\" to the path. For more information, see Naming a File.
/// </para>
/// </param>
/// <param name="lpSecurityAttributes">
/// <para>
/// A pointer to a <c>SECURITY_ATTRIBUTES</c> structure. The <c>lpSecurityDescriptor</c> member of the structure specifies a security descriptor for the
/// new directory.
/// </para>
/// <para>
/// If lpSecurityAttributes is <c>NULL</c>, the directory gets a default security descriptor. The access control lists (ACL) in the default security
/// descriptor for a directory are inherited from its parent directory.
/// </para>
/// <para>
/// The target file system must support security on files and directories for this parameter to have an effect. This is indicated when
/// <para>If the function succeeds, the return value is nonzero.</para>
/// <para>
/// If the function fails, the return value is zero (0). To get extended error information, call <c>GetLastError</c>. Possible errors include the following.
/// One or more intermediate directories do not exist. This function only creates the final directory in the path. To create all intermediate directories
/// on the path, use the SHCreateDirectoryEx function.
/// Establishes a hard link between an existing file and a new file. This function is only supported on the NTFS file system, and only for files, not directories.
/// In the ANSI version of this function, the name is limited to <c>MAX_PATH</c> characters. To extend this limit to 32,767 wide characters, call the
/// Unicode version of the function and prepend "\\?\" to the path. For more information, see Naming a File.
/// </para>
/// <note><c>Tip</c> Starting with Windows 10, version 1607, for the Unicode version of this function ( <c>CreateHardLinkW</c>), you can opt-in to remove
/// the <c>MAX_PATH</c> limitation without prepending "\\?\". See the "Maximum Path Length Limitation" section of Naming Files, Paths, and Namespaces for details.</note>
/// In the ANSI version of this function, the name is limited to <c>MAX_PATH</c> characters. To extend this limit to 32,767 wide characters, call the
/// Unicode version of the function and prepend "\\?\" to the path. For more information, see Naming a File.
/// </para>
/// <note><c>Tip</c> Starting with Windows 10, version 1607, for the Unicode version of this function ( <c>CreateHardLinkW</c>), you can opt-in to remove
/// the <c>MAX_PATH</c> limitation without prepending "\\?\". See the "Maximum Path Length Limitation" section of Naming Files, Paths, and Namespaces for details.</note>
/// This parameter may include the path. In the ANSI version of this function, the name is limited to <c>MAX_PATH</c> characters. To extend this limit to
/// 32,767 wide characters, call the Unicode version of the function and prepend "\\?\" to the path. For more information, see Naming a File.
/// </para>
/// <note><c>Tip</c> Starting with Windows 10, version 1607, for the Unicode version of this function ( <c>CreateSymbolicLinkW</c>), you can opt-in to
/// remove the <c>MAX_PATH</c> limitation without prepending "\\?\". See the "Maximum Path Length Limitation" section of Naming Files, Paths, and
/// Namespaces for details.</note>
/// </param>
/// <param name="lpTargetFileName">
/// The name of the target for the symbolic link to be created.
/// <para>
/// If lpTargetFileName has a device name associated with it, the link is treated as an absolute link; otherwise, the link is treated as a relative link.
/// </para>
/// <para>
/// This parameter may include the path. In the ANSI version of this function, the name is limited to <c>MAX_PATH</c> characters. To extend this limit to
/// 32,767 wide characters, call the Unicode version of the function and prepend "\\?\" to the path. For more information, see Naming a File.
/// </para>
/// <note><c>Tip</c> Starting with Windows 10, version 1607, for the Unicode version of this function ( <c>CreateSymbolicLinkW</c>), you can opt-in to
/// remove the <c>MAX_PATH</c> limitation without prepending "\\?\". See the "Maximum Path Length Limitation" section of Naming Files, Paths, and
/// Namespaces for details.</note>
/// </param>
/// <param name="dwFlags">Indicates whether the link target, lpTargetFileName, is a directory.</param>
/// <returns>
/// f the function succeeds, the return value is nonzero. If the function fails, the return value is zero.To get extended error information, call GetLastError.
/// Creates an enumeration of all the hard links to the specified file. The <c>FindFirstFileNameW</c> function returns a handle to the enumeration that
/// can be used on subsequent calls to the <c>FindNextFileNameW</c> function.
/// </para>
/// <para>To perform this operation as a transacted operation, use the <c>FindFirstFileNameTransactedW</c> function.</para>
/// </summary>
/// <param name="lpFileName">
/// <para>The name of the file.</para>
/// </param>
/// <param name="dwFlags">
/// <para>Reserved; specify zero (0).</para>
/// </param>
/// <param name="StringLength">
/// <para>
/// The size of the buffer pointed to by the LinkName parameter, in characters. If this call fails and the error returned from the <c>GetLastError</c>
/// function is <c>ERROR_MORE_DATA</c> (234), the value that is returned by this parameter is the size that the buffer pointed to by LinkName must be to
/// contain all the data.
/// </para>
/// </param>
/// <param name="LinkName">
/// <para>A pointer to a buffer to store the first link name found for lpFileName.</para>
/// </param>
/// <returns>
/// <para>
/// If the function succeeds, the return value is a search handle that can be used with the <c>FindNextFileNameW</c> function or closed with the
/// <c>FindClose</c> function.
/// </para>
/// <para>
/// If the function fails, the return value is <c>INVALID_HANDLE_VALUE</c> (0xffffffff). To get extended error information, call the <c>GetLastError</c> function.
/// <para>The information level of the returned data. This parameter is one of the values in the <c>STREAM_INFO_LEVELS</c> enumeration type.</para>
/// <para>
/// <list type="table">
/// <listheader>
/// <term>Value</term>
/// <term>Meaning</term>
/// </listheader>
/// <item>
/// <term>FindStreamInfoStandard = 0</term>
/// <term>The data is returned in a WIN32_FIND_STREAM_DATA structure.</term>
/// </item>
/// </list>
/// </para>
/// </param>
/// <param name="lpFindStreamData">
/// A pointer to a buffer that receives the file stream data. The format of this data depends on the value of the InfoLevel parameter.
/// </param>
/// <param name="dwFlags">Reserved for future use. This parameter must be zero.</param>
/// <returns>
/// <para>If the function succeeds, the return value is a search handle that can be used in subsequent calls to the <c>FindNextStreamW</c> function.</para>
/// <para>If the function fails, the return value is <c>INVALID_HANDLE_VALUE</c>. To get extended error information, call <c>GetLastError</c>.</para>
/// <para>If no streams can be found, the function fails and <c>GetLastError</c> returns <c>ERROR_HANDLE_EOF</c> (38).</para>
/// Retrieves the name of a mounted folder on the specified volume. <c>FindFirstVolumeMountPoint</c> is used to begin scanning the mounted folders on a volume.
/// </summary>
/// <param name="lpszRootPathName">A volume GUID path for the volume to scan for mounted folders. A trailing backslash is required.</param>
/// <param name="lpszVolumeMountPoint">A pointer to a buffer that receives the name of the first mounted folder that is found.</param>
/// <param name="cchBufferLength">The length of the buffer that receives the path to the mounted folder, in <c>TCHAR</c> s.</param>
/// <returns>
/// <para>
/// If the function succeeds, the return value is a search handle used in a subsequent call to the <c>FindNextVolumeMountPoint</c> and
/// <c>FindVolumeMountPointClose</c> functions.
/// </para>
/// <para>
/// If the function fails to find a mounted folder on the volume, the return value is the <c>INVALID_HANDLE_VALUE</c> error code. To get extended error
/// <para>Continues enumerating the hard links to a file using the handle returned by a successful call to the <c>FindFirstFileNameW</c> function.</para>
/// </summary>
/// <param name="hFindStream">
/// <para>A handle to the enumeration that is returned by a successful call to <c>FindFirstFileNameW</c>.</para>
/// </param>
/// <param name="StringLength">
/// <para>
/// The size of the LinkName parameter, in characters. If this call fails and the error is <c>ERROR_MORE_DATA</c>, the value that is returned by this
/// parameter is the size that LinkName must be to contain all the data.
/// </para>
/// </param>
/// <param name="LinkName">
/// <para>A pointer to a buffer to store the first link name found for lpFileName.</para>
/// </param>
/// <returns>
/// <para>If the function succeeds, the return value is nonzero.</para>
/// <para>If the function fails, the return value is zero (0). To get extended error information, call <c>GetLastError</c>.</para>
/// <para>If no matching files can be found, the <c>GetLastError</c> function returns <c>ERROR_HANDLE_EOF</c>.</para>
/// Continues a mounted folder search started by a call to the <c>FindFirstVolumeMountPoint</c> function. <c>FindNextVolumeMountPoint</c> finds one
/// mounted folder per call.
/// </summary>
/// <param name="hFindVolumeMountPoint">A mounted folder search handle returned by a previous call to the <c>FindFirstVolumeMountPoint</c> function.</param>
/// <param name="lpszVolumeMountPoint">A pointer to a buffer that receives the name of the mounted folder that is found.</param>
/// <param name="cchBufferLength">The length of the buffer that receives the mounted folder name, in <c>TCHARs</c>.</param>
/// <returns>
/// <para>If the function succeeds, the return value is nonzero.</para>
/// <para>
/// If the function fails, the return value is zero. To get extended error information, call <c>GetLastError</c>. If no more mounted folders can be
/// found, the <c>GetLastError</c> function returns the <c>ERROR_NO_MORE_FILES</c> error code. In that case, close the search with the
/// Closes the specified mounted folder search handle. The <c>FindFirstVolumeMountPoint</c> and <c>FindNextVolumeMountPoint</c> functions use this search
/// handle to locate mounted folders on a specified volume.
/// </summary>
/// <param name="hFindVolumeMountPoint">
/// The mounted folder search handle to be closed. This handle must have been previously opened by the <c>FindFirstVolumeMountPoint</c> function.
/// </param>
/// <returns>
/// <para>If the function succeeds, the return value is nonzero.</para>
/// <para>If the function fails, the return value is zero. To get extended error information, call <c>GetLastError</c>.</para>
/// Retrieves the actual number of bytes of disk storage used to store a specified file. If the file is located on a volume that supports compression and
/// the file is compressed, the value obtained is the compressed size of the specified file. If the file is located on a volume that supports sparse
/// files and the file is a sparse file, the value obtained is the sparse size of the specified file.
/// </summary>
/// <param name="lpFileName">
/// The name of the file.
/// <para>Do not specify the name of a file on a nonseeking device, such as a pipe or a communications device, as its file size has no meaning.</para>
/// <para>
/// This parameter may include the path. In the ANSI version of this function, the name is limited to <see cref="MAX_PATH"/> characters. To extend this
/// The high-order DWORD of the compressed file size. The function's return value is the low-order DWORD of the compressed file size.
/// <para>
/// This parameter can be NULL if the high-order DWORD of the compressed file size is not needed.Files less than 4 gigabytes in size do not need the
/// high-order DWORD.
/// </para>
/// </param>
/// <returns>
/// If the function succeeds, the return value is the low-order DWORD of the actual number of bytes of disk storage used to store the specified file, and
/// if <paramref name="lpFileSizeHigh"/> is non-NULL, the function puts the high-order DWORD of that actual value into the DWORD pointed to by that
/// parameter. This is the compressed file size for compressed files, the actual file size for noncompressed files.
/// <para>
/// If the function fails, and <paramref name="lpFileSizeHigh"/> is NULL, the return value is INVALID_FILE_SIZE. To get extended error information, call GetLastError.
/// </para>
/// <para>
/// If the return value is INVALID_FILE_SIZE and <paramref name="lpFileSizeHigh"/> is non-NULL, an application must call GetLastError to determine
/// whether the function has succeeded (value is NO_ERROR) or failed (value is other than NO_ERROR).
/// <para>Moves an existing file or a directory, including its children.</para>
/// <para>To specify how to move the file, use the <c>MoveFileEx</c> or <c>MoveFileWithProgress</c> function.</para>
/// <para>To perform this operation as a transacted operation, use the <c>MoveFileTransacted</c> function.</para>
/// </summary>
/// <param name="lpExistingFileName">
/// <para>The current name of the file or directory on the local computer.</para>
/// <para>
/// In the ANSI version of this function, the name is limited to <c>MAX_PATH</c> characters. To extend this limit to 32,767 wide characters, call the
/// Unicode version of the function and prepend "\\?\" to the path. For more information, see Naming a File.
/// </para>
/// </param>
/// <param name="lpNewFileName">
/// <para>
/// The new name for the file or directory. The new name must not already exist. A new file may be on a different file system or drive. A new directory
/// must be on the same drive.
/// </para>
/// <para>
/// In the ANSI version of this function, the name is limited to <c>MAX_PATH</c> characters. To extend this limit to 32,767 wide characters, call the
/// Unicode version of the function and prepend "\\?\" to the path. For more information, see Naming a File.
/// </para>
/// </param>
/// <returns>
/// <para>If the function succeeds, the return value is nonzero.</para>
/// <para>If the function fails, the return value is zero. To get extended error information, call <c>GetLastError</c>.</para>
/// <para>Moves an existing file or directory, including its children, with various move options.</para>
/// <para>
/// The <c>MoveFileWithProgress</c> function is equivalent to the <c>MoveFileEx</c> function, except that <c>MoveFileWithProgress</c> allows you to
/// provide a callback function that receives progress notifications.
/// </para>
/// <para>To perform this operation as a transacted operation, use the <c>MoveFileTransacted</c> function.</para>
/// </summary>
/// <param name="lpExistingFileName">
/// <para>The current name of the file or directory on the local computer.</para>
/// <para>
/// If dwFlags specifies <c>MOVEFILE_DELAY_UNTIL_REBOOT</c>, the file cannot exist on a remote share, because delayed operations are performed before the
/// network is available.
/// </para>
/// <para>
/// In the ANSI version of this function, the name is limited to <c>MAX_PATH</c> characters. To extend this limit to 32,767 wide characters, call the
/// Unicode version of the function and prepend "\\?\" to the path. For more information, see Naming a File
/// </para>
/// </param>
/// <param name="lpNewFileName">
/// <para>The new name of the file or directory on the local computer.</para>
/// <para>
/// When moving a file, the destination can be on a different file system or volume. If the destination is on another drive, you must set the
/// <c>MOVEFILE_COPY_ALLOWED</c> flag in dwFlags.
/// </para>
/// <para>When moving a directory, the destination must be on the same drive.</para>
/// <para>
/// If dwFlags specifies <c>MOVEFILE_DELAY_UNTIL_REBOOT</c> and lpNewFileName is <c>NULL</c>, <c>MoveFileEx</c> registers the lpExistingFileName file to
/// be deleted when the system restarts. If lpExistingFileName refers to a directory, the system removes the directory at restart only if the directory
/// is empty.
/// </para>
/// <para>
/// In the ANSI version of this function, the name is limited to <c>MAX_PATH</c> characters. To extend this limit to 32,767 wide characters, call the
/// Unicode version of the function and prepend "\\?\" to the path. For more information, see Naming a File
/// </para>
/// </param>
/// <param name="dwFlags">
/// <para>This parameter can be one or more of the following values.</para>
/// <para>
/// <list type="table">
/// <listheader>
/// <term>Value</term>
/// <term>Meaning</term>
/// </listheader>
/// <item>
/// <term>MOVEFILE_COPY_ALLOWED2 (0x2)</term>
/// <term>
/// If the file is to be moved to a different volume, the function simulates the move by using the CopyFile and DeleteFile functions.If the file is
/// successfully copied to a different volume and the original file is unable to be deleted, the function succeeds leaving the source file intact.This
/// value cannot be used with MOVEFILE_DELAY_UNTIL_REBOOT.
/// The system does not move the file until the operating system is restarted. The system moves the file immediately after AUTOCHK is executed, but
/// before creating any paging files. Consequently, this parameter enables the function to delete paging files from previous startups.This value can be
/// used only if the process is in the context of a user who belongs to the administrators group or the LocalSystem account. This value cannot be used
/// with MOVEFILE_COPY_ALLOWED.Windows Server 2003 and Windows XP: For information about special situations where this functionality can fail, and a
/// suggested workaround solution, see Files are not exchanged when Windows Server 2003 restarts if you use the MoveFileEx function to schedule a
/// replacement for some files in the Help and Support Knowledge Base.
/// The function fails if the source file is a link source, but the file cannot be tracked after the move. This situation can occur if the destination is
/// a volume formatted with the FAT file system.
/// </term>
/// </item>
/// <item>
/// <term>MOVEFILE_REPLACE_EXISTING1 (0x1)</term>
/// <term>
/// If a file named lpNewFileName exists, the function replaces its contents with the contents of the lpExistingFileName file, provided that security
/// requirements regarding access control lists (ACLs) are met. For more information, see the Remarks section of this topic.This value cannot be used if
/// lpNewFileName or lpExistingFileName names a directory.
/// </term>
/// </item>
/// <item>
/// <term>MOVEFILE_WRITE_THROUGH8 (0x8)</term>
/// <term>
/// The function does not return until the file is actually moved on the disk.Setting this value guarantees that a move performed as a copy and delete
/// operation is flushed to disk before the function returns. The flush occurs at the end of the copy operation.This value has no effect if
/// MOVEFILE_DELAY_UNTIL_REBOOT is set.
/// </term>
/// </item>
/// </list>
/// </para>
/// </param>
/// <returns>
/// <para>If the function succeeds, the return value is nonzero.</para>
/// <para>If the function fails, the return value is zero (0). To get extended error information, call <c>GetLastError</c>.</para>
/// <para>Moves a file or directory, including its children. You can provide a callback function that receives progress notifications.</para>
/// <para>To perform this operation as a transacted operation, use the <c>MoveFileTransacted</c> function.</para>
/// </summary>
/// <param name="lpExistingFileName">
/// <para>The name of the existing file or directory on the local computer.</para>
/// <para>
/// If dwFlags specifies <c>MOVEFILE_DELAY_UNTIL_REBOOT</c>, the file cannot exist on a remote share because delayed operations are performed before the
/// network is available.
/// </para>
/// <para>
/// In the ANSI version of this function, the name is limited to <c>MAX_PATH</c> characters. To extend this limit to 32,767 wide characters, call the
/// Unicode version of the function and prepend "\\?\" to the path. For more information, see Naming a File.
/// </para>
/// </param>
/// <param name="lpNewFileName">
/// <para>The new name of the file or directory on the local computer.</para>
/// <para>
/// When moving a file, lpNewFileName can be on a different file system or volume. If lpNewFileName is on another drive, you must set the
/// <c>MOVEFILE_COPY_ALLOWED</c> flag in dwFlags.
/// </para>
/// <para>When moving a directory, lpExistingFileName and lpNewFileName must be on the same drive.</para>
/// <para>
/// If dwFlags specifies <c>MOVEFILE_DELAY_UNTIL_REBOOT</c> and lpNewFileName is <c>NULL</c>, <c>MoveFileWithProgress</c> registers lpExistingFileName to
/// be deleted when the system restarts. The function fails if it cannot access the registry to store the information about the delete operation. If
/// lpExistingFileName refers to a directory, the system removes the directory at restart only if the directory is empty.
/// </para>
/// <para>
/// In the ANSI version of this function, the name is limited to <c>MAX_PATH</c> characters. To extend this limit to 32,767 wide characters, call the
/// Unicode version of the function and prepend "\\?\" to the path. For more information, see Naming a File.
/// </para>
/// </param>
/// <param name="lpProgressRoutine">
/// A pointer to a <c>CopyProgressRoutine</c> callback function that is called each time another portion of the file has been moved. The callback
/// function can be useful if you provide a user interface that displays the progress of the operation. This parameter can be <c>NULL</c>.
/// </param>
/// <param name="lpData">An argument to be passed to the <c>CopyProgressRoutine</c> callback function. This parameter can be <c>NULL</c>.</param>
/// <param name="dwFlags">
/// <para>The move options. This parameter can be one or more of the following values.</para>
/// <para>
/// <list type="table">
/// <listheader>
/// <term>Value</term>
/// <term>Meaning</term>
/// </listheader>
/// <item>
/// <term>MOVEFILE_COPY_ALLOWED2 (0x2)</term>
/// <term>
/// If the file is to be moved to a different volume, the function simulates the move by using the CopyFile and DeleteFile functions.If the file is
/// successfully copied to a different volume and the original file is unable to be deleted, the function succeeds leaving the source file intact.This
/// value cannot be used with MOVEFILE_DELAY_UNTIL_REBOOT.
/// The system does not move the file until the operating system is restarted. The system moves the file immediately after AUTOCHK is executed, but
/// before creating any paging files. Consequently, this parameter enables the function to delete paging files from previous startups.This value can only
/// be used if the process is in the context of a user who belongs to the administrators group or the LocalSystem account.This value cannot be used with MOVEFILE_COPY_ALLOWED.
/// The function fails if the source file is a link source, but the file cannot be tracked after the move. This situation can occur if the destination is
/// a volume formatted with the FAT file system.
/// </term>
/// </item>
/// <item>
/// <term>MOVEFILE_REPLACE_EXISTING1 (0x1)</term>
/// <term>
/// If a file named lpNewFileName exists, the function replaces its contents with the contents of the lpExistingFileName file.This value cannot be used
/// if lpNewFileName or lpExistingFileName names a directory.
/// </term>
/// </item>
/// <item>
/// <term>MOVEFILE_WRITE_THROUGH8 (0x8)</term>
/// <term>
/// The function does not return until the file has actually been moved on the disk.Setting this value guarantees that a move performed as a copy and
/// delete operation is flushed to disk before the function returns. The flush occurs at the end of the copy operation.This value has no effect if
/// MOVEFILE_DELAY_UNTIL_REBOOT is set.
/// </term>
/// </item>
/// </list>
/// </para>
/// </param>
/// <returns>
/// <para>If the function succeeds, the return value is nonzero.</para>
/// <para>If the function fails, the return value is zero. To get extended error information, call <c>GetLastError</c>.</para>
/// <para>
/// When moving a file across volumes, if lpProgressRoutine returns <c>PROGRESS_CANCEL</c> due to the user canceling the operation,
/// <c>MoveFileWithProgress</c> will return zero and <c>GetLastError</c> will return <c>ERROR_REQUEST_ABORTED</c>. The existing file is left intact.
/// </para>
/// <para>
/// When moving a file across volumes, if lpProgressRoutine returns <c>PROGRESS_STOP</c> due to the user stopping the operation,
/// <c>MoveFileWithProgress</c> will return zero and <c>GetLastError</c> will return <c>ERROR_REQUEST_ABORTED</c>. The existing file is left intact.
/// <summary>Creates, opens, reopens, or deletes a file.</summary>
/// <param name="lpFileName">
/// <para>The name of the file.</para>
/// <para>
/// The string must consist of characters from the 8-bit Windows character set. The <c>OpenFile</c> function does not support Unicode file names or
/// opening named pipes.
/// </para>
/// </param>
/// <param name="lpReOpenBuff">
/// <para>A pointer to the <c>OFSTRUCT</c> structure that receives information about a file when it is first opened.</para>
/// <para>The structure can be used in subsequent calls to the <c>OpenFile</c> function to see an open file.</para>
/// <para>
/// The <c>OFSTRUCT</c> structure contains a path string member with a length that is limited to <c>OFS_MAXPATHNAME</c> characters, which is 128
/// characters. Because of this, you cannot use the <c>OpenFile</c> function to open a file with a path length that exceeds 128 characters. The
/// <c>CreateFile</c> function does not have this path length limitation.
/// </para>
/// </param>
/// <param name="uStyle">
/// <para>The action to be taken.</para>
/// <para>This parameter can be one or more of the following values.</para>
/// <para>
/// <list type="table">
/// <listheader>
/// <term>Value</term>
/// <term>Meaning</term>
/// </listheader>
/// <item>
/// <term>OF_CANCEL0x00000800</term>
/// <term>Ignored.To produce a dialog box containing a Cancel button, use OF_PROMPT.</term>
/// </item>
/// <item>
/// <term>OF_CREATE0x00001000</term>
/// <term>Creates a new file.If the file exists, it is truncated to zero (0) length.</term>
/// </item>
/// <item>
/// <term>OF_DELETE0x00000200</term>
/// <term>Deletes a file.</term>
/// </item>
/// <item>
/// <term>OF_EXIST0x00004000</term>
/// <term>Opens a file and then closes it.Use this to test for the existence of a file.</term>
/// </item>
/// <item>
/// <term>OF_PARSE0x00000100</term>
/// <term>Fills the OFSTRUCT structure, but does not do anything else.</term>
/// </item>
/// <item>
/// <term>OF_PROMPT0x00002000</term>
/// <term>
/// Displays a dialog box if a requested file does not exist.A dialog box informs a user that the system cannot find a file, and it contains Retry and
/// Cancel buttons. The Cancel button directs OpenFile to return a file-not-found error message.
/// </term>
/// </item>
/// <item>
/// <term>OF_READ0x00000000</term>
/// <term>Opens a file for reading only.</term>
/// </item>
/// <item>
/// <term>OF_READWRITE0x00000002</term>
/// <term>Opens a file with read/write permissions.</term>
/// </item>
/// <item>
/// <term>OF_REOPEN0x00008000</term>
/// <term>Opens a file by using information in the reopen buffer.</term>
/// </item>
/// <item>
/// <term>OF_SHARE_COMPAT0x00000000</term>
/// <term>
/// For MS-DOS–based file systems, opens a file with compatibility mode, allows any process on a specified computer to open the file any number of
/// times.Other efforts to open a file with other sharing modes fail. This flag is mapped to the FILE_SHARE_READ|FILE_SHARE_WRITE flags of the CreateFile function.
/// </term>
/// </item>
/// <item>
/// <term>OF_SHARE_DENY_NONE0x00000040</term>
/// <term>
/// Opens a file without denying read or write access to other processes.On MS-DOS-based file systems, if the file has been opened in compatibility mode
/// by any other process, the function fails.This flag is mapped to the FILE_SHARE_READ|FILE_SHARE_WRITE flags of the CreateFile function.
/// </term>
/// </item>
/// <item>
/// <term>OF_SHARE_DENY_READ0x00000030</term>
/// <term>
/// Opens a file and denies read access to other processes.On MS-DOS-based file systems, if the file has been opened in compatibility mode, or for read
/// access by any other process, the function fails.This flag is mapped to the FILE_SHARE_WRITE flag of the CreateFile function.
/// </term>
/// </item>
/// <item>
/// <term>OF_SHARE_DENY_WRITE0x00000020</term>
/// <term>
/// Opens a file and denies write access to other processes.On MS-DOS-based file systems, if a file has been opened in compatibility mode, or for write
/// access by any other process, the function fails.This flag is mapped to the FILE_SHARE_READ flag of the CreateFile function.
/// </term>
/// </item>
/// <item>
/// <term>OF_SHARE_EXCLUSIVE0x00000010</term>
/// <term>
/// Opens a file with exclusive mode, and denies both read/write access to other processes. If a file has been opened in any other mode for read/write
/// access, even by the current process, the function fails.
/// </term>
/// </item>
/// <item>
/// <term>OF_VERIFY</term>
/// <term>Verifies that the date and time of a file are the same as when it was opened previously.This is useful as an extra check for read-only files.</term>
/// </item>
/// <item>
/// <term>OF_WRITE0x00000001</term>
/// <term>Opens a file for write access only.</term>
/// </item>
/// </list>
/// </para>
/// </param>
/// <returns>
/// <para>
/// If the function succeeds, the return value specifies a file handle to use when performing file I/O. To close the file, call the <c>CloseHandle</c>
/// function using this handle.
/// </para>
/// <para>If the function fails, the return value is <c>HFILE_ERROR</c>. To get extended error information, call <c>GetLastError</c>.</para>
/// Retrieves information that describes the changes within the specified directory. The function does not report changes to the specified directory itself.
/// </para>
/// <para>To track changes on a volume, see change journals.</para>
/// </summary>
/// <param name="hDirectory">
/// A handle to the directory to be monitored. This directory must be opened with the <c>FILE_LIST_DIRECTORY</c> access right, or an access right such as
/// <c>GENERIC_READ</c> that includes the <c>FILE_LIST_DIRECTORY</c> access right.
/// </param>
/// <param name="lpBuffer">
/// A pointer to the <c>DWORD</c>-aligned formatted buffer in which the read results are to be returned. The structure of this buffer is defined by the
/// <c>FILE_NOTIFY_INFORMATION</c> structure. This buffer is filled either synchronously or asynchronously, depending on how the directory is opened and
/// what value is given to the lpOverlapped parameter. For more information, see the Remarks section.
/// </param>
/// <param name="nBufferLength">The size of the buffer that is pointed to by the lpBuffer parameter, in bytes.</param>
/// <param name="bWatchSubtree">
/// If this parameter is <c>TRUE</c>, the function monitors the directory tree rooted at the specified directory. If this parameter is <c>FALSE</c>, the
/// function monitors only the directory specified by the hDirectory parameter.
/// </param>
/// <param name="dwNotifyFilter">
/// <para>
/// The filter criteria that the function checks to determine if the wait operation has completed. This parameter can be one or more of the following values.
/// Any file name change in the watched directory or subtree causes a change notification wait operation to return. Changes include renaming, creating,
/// Any file-size change in the watched directory or subtree causes a change notification wait operation to return. The operating system detects a change
/// in file size only when the file is written to the disk. For operating systems that use extensive caching, detection occurs only when the cache is
/// Any change to the last write-time of files in the watched directory or subtree causes a change notification wait operation to return. The operating
/// system detects a change to the last write-time only when the file is written to the disk. For operating systems that use extensive caching, detection
/// occurs only when the cache is sufficiently flushed.
/// <term>Any change to the last access time of files in the watched directory or subtree causes a change notification wait operation to return.</term>
/// <term>Any security-descriptor change in the watched directory or subtree causes a change notification wait operation to return.</term>
/// </item>
/// </list>
/// </para>
/// </param>
/// <param name="lpBytesReturned">
/// For synchronous calls, this parameter receives the number of bytes transferred into the lpBuffer parameter. For asynchronous calls, this parameter is
/// undefined. You must use an asynchronous notification technique to retrieve the number of bytes transferred.
/// </param>
/// <param name="lpOverlapped">
/// A pointer to an <c>OVERLAPPED</c> structure that supplies data to be used during asynchronous operation. Otherwise, this value is <c>NULL</c>. The
/// <c>Offset</c> and <c>OffsetHigh</c> members of this structure are not used.
/// </param>
/// <param name="lpCompletionRoutine">
/// A pointer to a completion routine to be called when the operation has been completed or canceled and the calling thread is in an alertable wait
/// state. For more information about this completion routine, see <c>FileIOCompletionRoutine</c>.
/// </param>
/// <returns>
/// <para>
/// If the function succeeds, the return value is nonzero. For synchronous calls, this means that the operation succeeded. For asynchronous calls, this
/// indicates that the operation was successfully queued.
/// </para>
/// <para>If the function fails, the return value is zero. To get extended error information, call <c>GetLastError</c>.</para>
/// <para>If the network redirector or the target file system does not support this operation, the function fails with <c>ERROR_INVALID_FUNCTION</c>.</para>
/// Replaces one file with another file, with the option of creating a backup copy of the original file. The replacement file assumes the name of the
/// replaced file and its identity.
/// </summary>
/// <param name="lpReplacedFileName">
/// <para>The name of the file to be replaced.</para>
/// <para>
/// In the ANSI version of this function, the name is limited to <c>MAX_PATH</c> characters. To extend this limit to 32,767 wide characters, call the
/// Unicode version of the function and prepend "\\?\" to the path. For more information, see Naming a File.
/// </para>
/// <para>
/// This file is opened with the <c>GENERIC_READ</c>, <c>DELETE</c>, and <c>SYNCHRONIZE</c> access rights. The sharing mode is <c>FILE_SHARE_READ</c> |
/// <para>The caller must have write access to the file to be replaced. For more information, see File Security and Access Rights.</para>
/// </param>
/// <param name="lpReplacementFileName">
/// <para>The name of the file that will replace the lpReplacedFileName file.</para>
/// <para>
/// In the ANSI version of this function, the name is limited to <c>MAX_PATH</c> characters. To extend this limit to 32,767 wide characters, call the
/// Unicode version of the function and prepend "\\?\" to the path. For more information, see Naming a File.
/// </para>
/// <para>
/// The function attempts to open this file with the <c>SYNCHRONIZE</c>, <c>GENERIC_READ</c>, <c>GENERIC_WRITE</c>, <c>DELETE</c>, and <c>WRITE_DAC</c>
/// access rights so that it can preserve all attributes and ACLs. If this fails, the function attempts to open the file with the <c>SYNCHRONIZE</c>,
/// <c>GENERIC_READ</c>, <c>DELETE</c>, and <c>WRITE_DAC</c> access rights. No sharing mode is specified.
/// </para>
/// </param>
/// <param name="lpBackupFileName">
/// <para>
/// The name of the file that will serve as a backup copy of the lpReplacedFileName file. If this parameter is <c>NULL</c>, no backup file is created.
/// See the Remarks section for implementation details on the backup file.
/// </para>
/// <para>
/// In the ANSI version of this function, the name is limited to <c>MAX_PATH</c> characters. To extend this limit to 32,767 wide characters, call the
/// Unicode version of the function and prepend "\\?\" to the path. For more information, see Naming a File.
/// </para>
/// </param>
/// <param name="dwReplaceFlags">
/// <para>The replacement options. This parameter can be one or more of the following values.</para>
/// Ignores errors that occur while merging information (such as attributes and ACLs) from the replaced file to the replacement file. Therefore, if you
/// specify this flag and do not have WRITE_DAC access, the function succeeds but the ACLs are not preserved.
/// Ignores errors that occur while merging ACL information from the replaced file to the replacement file. Therefore, if you specify this flag and do
/// not have WRITE_DAC access, the function succeeds but the ACLs are not preserved. To compile an application that uses this value, define the
/// _WIN32_WINNT macro as 0x0600 or later.Windows Server 2003 and Windows XP: This value is not supported.
/// </term>
/// </item>
/// </list>
/// </para>
/// </param>
/// <param name="lpExclude">Reserved for future use.</param>
/// <param name="lpReserved">Reserved for future use.</param>
/// <returns>
/// <para>If the function succeeds, the return value is nonzero.</para>
/// <para>
/// If the function fails, the return value is zero. To get extended error information, call <c>GetLastError</c>. The following are possible error codes
/// <term>The replaced file could not be deleted. The replaced and replacement files retain their original file names.</term>
/// </item>
/// </list>
/// </para>
/// <para>
/// If any other error is returned, such as <c>ERROR_INVALID_PARAMETER</c>, the replaced and replacement files will retain their original file names. In
/// this scenario, a backup file does not exist and it is not guaranteed that the replacement file will have inherited all of the attributes and streams
/// Causes the file I/O functions for the process to use the OEM character set code page. This function is useful for 8-bit console input and output operations.
/// </para>
/// </summary>
/// <returns>
/// <para>This function does not return a value.</para>
/// Associates a virtual address range with the specified file handle. This indicates that the kernel should optimize any further asynchronous I/O
/// requests with overlapped structures inside this range. The overlapped range is locked in memory, and then unlocked when the file is closed. After a
/// range is associated with a file handle, it cannot be disassociated.
/// </para>
/// </summary>
/// <param name="FileHandle">
/// <para>A handle to the file.</para>
/// <para>This file handle must be opened with <c>FILE_READ_ATTRIBUTES</c> access rights.</para>
/// </param>
/// <param name="OverlappedRangeStart">
/// <para>The starting address for the range.</para>
/// </param>
/// <param name="Length">
/// <para>The length of the range, in bytes.</para>
/// </param>
/// <returns>
/// <para>Returns nonzero if successful or zero otherwise.</para>
/// <para>To get extended error information, call <c>GetLastError</c>.</para>
/// <para>A pointer to a string that specifies the short name for the file.</para>
/// <para>
/// Specifying an empty (zero-length) string will remove the short file name, if it exists for the file specified by the hFile parameter. If a short file
/// name does not exist, the function will do nothing and return success.
/// </para>
/// <para>
/// <c>Windows Server 2008, Windows Vista, Windows Server 2003 and Windows XP:</c> This behavior is not supported. The parameter must contain a valid
/// string of one or more characters.
/// </para>
/// </param>
/// <returns>
/// <para>If the function succeeds, the return value is nonzero.</para>
/// <para>
/// If the function fails, the return value is zero. To get extended error information, call <c>GetLastError</c>. <c>GetLastError</c> may return one of
/// the following error codes that are specific to this function.
/// </para>
/// <para>
/// <list type="table">
/// <listheader>
/// <term>Return code</term>
/// <term>Description</term>
/// </listheader>
/// <item>
/// <term>ERROR_ALREADY_EXISTS</term>
/// <term>The specified short name is not unique.</term>
/// </item>
/// <item>
/// <term>ERROR_INVALID_PARAMETER</term>
/// <term>Either the specified file has been opened in case-sensitive mode or the specified short name is invalid.</term>
/// <summary>Represents a search handle used in a subsequent call to the <c>FindNextVolumeMountPoint</c> and retrieved by <c>FindFirstVolumeMountPoint</c>.</summary>