using System;
using System.Runtime.InteropServices;
using Vanara.Extensions;
using Vanara.InteropServices;
using static Vanara.PInvoke.Kernel32;

namespace Vanara.PInvoke
{
	/// <summary>Functions, structures and constants from CldApi.dll.</summary>
	public static partial class CldApi
	{
		private const int CF_MAX_PROVIDER_NAME_LENGTH = 255;

		private const int CF_MAX_PROVIDER_VERSION_LENGTH = 255;

		/// <summary>Callback flags for canceling data fetching for a placeholder file or folder.</summary>
		// https://docs.microsoft.com/en-us/windows/win32/api/cfapi/ne-cfapi-cf_callback_cancel_flags typedef enum CF_CALLBACK_CANCEL_FLAGS
		// { CF_CALLBACK_CANCEL_FLAG_NONE, CF_CALLBACK_CANCEL_FLAG_IO_TIMEOUT, CF_CALLBACK_CANCEL_FLAG_IO_ABORTED } ;
		[PInvokeData("cfapi.h", MSDNShortId = "16F0BB1E-FB9E-4AC3-8FD9-A540F72F1155")]
		[Flags]
		public enum CF_CALLBACK_CANCEL_FLAGS
		{
			/// <summary>No cancel flag.</summary>
			CF_CALLBACK_CANCEL_FLAG_NONE = 0,

			/// <summary>Flag to be set if the user request is cancelled as a result of the expiration of the 60 second timer.</summary>
			CF_CALLBACK_CANCEL_FLAG_IO_TIMEOUT = 1,

			/// <summary>
			/// Flag to be set if the user request is cancelled as a result of the user explicitly terminating the hydration from
			/// app-initiated download toast.
			/// </summary>
			CF_CALLBACK_CANCEL_FLAG_IO_ABORTED = 2,
		}

		/// <summary>
		/// Callback flags for notifying a sync provider that a placeholder under one of its sync roots that has been previously opened for
		/// read/write/delete access is now closed.
		/// </summary>
		// https://docs.microsoft.com/en-us/windows/win32/api/cfapi/ne-cfapi-cf_callback_close_completion_flags typedef enum
		// CF_CALLBACK_CLOSE_COMPLETION_FLAGS { CF_CALLBACK_CLOSE_COMPLETION_FLAG_NONE, CF_CALLBACK_CLOSE_COMPLETION_FLAG_DELETED } ;
		[PInvokeData("cfapi.h", MSDNShortId = "D80D95FB-C53B-4A31-97B9-389BE73BE966")]
		[Flags]
		public enum CF_CALLBACK_CLOSE_COMPLETION_FLAGS
		{
			/// <summary>No close completion flags.</summary>
			CF_CALLBACK_CLOSE_COMPLETION_FLAG_NONE = 0,

			/// <summary>A flag set if a placeholder is deleted as a result of the close.</summary>
			CF_CALLBACK_CLOSE_COMPLETION_FLAG_DELETED = 1,
		}

		/// <summary>
		/// A callback flag to inform the sync provider that a placeholder under one of its sync roots has been successfully dehydrated.
		/// </summary>
		// https://docs.microsoft.com/en-us/windows/win32/api/cfapi/ne-cfapi-cf_callback_dehydrate_completion_flags typedef enum
		// CF_CALLBACK_DEHYDRATE_COMPLETION_FLAGS { CF_CALLBACK_DEHYDRATE_COMPLETION_FLAG_NONE,
		// CF_CALLBACK_DEHYDRATE_COMPLETION_FLAG_BACKGROUND, CF_CALLBACK_DEHYDRATE_COMPLETION_FLAG_DEHYDRATED } ;
		[PInvokeData("cfapi.h", MSDNShortId = "BB39BC4D-A5FF-4204-A7ED-30605B865F15")]
		[Flags]
		public enum CF_CALLBACK_DEHYDRATE_COMPLETION_FLAGS
		{
			/// <summary>No dehydration completion flag.</summary>
			CF_CALLBACK_DEHYDRATE_COMPLETION_FLAG_NONE = 0,

			/// <summary>A flag set if the dehydration request is initiated by a system background service.</summary>
			CF_CALLBACK_DEHYDRATE_COMPLETION_FLAG_BACKGROUND = 1,

			/// <summary>A flag set if the placeholder was hydrated prior to the dehydration request.</summary>
			CF_CALLBACK_DEHYDRATE_COMPLETION_FLAG_DEHYDRATED = 2,
		}

		/// <summary>Callback flags for notifying a sync provider that a placeholder under one of its sync root is going to be dehydrated.</summary>
		// https://docs.microsoft.com/en-us/windows/win32/api/cfapi/ne-cfapi-cf_callback_dehydrate_flags typedef enum
		// CF_CALLBACK_DEHYDRATE_FLAGS { CF_CALLBACK_DEHYDRATE_FLAG_NONE, CF_CALLBACK_DEHYDRATE_FLAG_BACKGROUND } ;
		[PInvokeData("cfapi.h", MSDNShortId = "DCB085EA-1468-44FB-9D45-F5C89693CBE7")]
		[Flags]
		public enum CF_CALLBACK_DEHYDRATE_FLAGS
		{
			/// <summary>No dehydrate flag.</summary>
			CF_CALLBACK_DEHYDRATE_FLAG_NONE = 0,

			/// <summary>A flag set if the dehydration request is initiated by a system background service.</summary>
			CF_CALLBACK_DEHYDRATE_FLAG_BACKGROUND = 1,
		}

		/// <summary/>
		[PInvokeData("cfapi.h")]
		public enum CF_CALLBACK_DEHYDRATION_REASON
		{
			/// <summary/>
			CF_CALLBACK_DEHYDRATION_REASON_NONE,

			/// <summary/>
			CF_CALLBACK_DEHYDRATION_REASON_USER_MANUAL,

			/// <summary/>
			CF_CALLBACK_DEHYDRATION_REASON_SYSTEM_LOW_SPACE,

			/// <summary/>
			CF_CALLBACK_DEHYDRATION_REASON_SYSTEM_INACTIVITY,

			/// <summary/>
			CF_CALLBACK_DEHYDRATION_REASON_SYSTEM_OS_UPGRADE,
		}

		/// <summary>Callback flags for notifying a sync provider that a placeholder was successfully deleted.</summary>
		// https://docs.microsoft.com/en-us/windows/win32/api/cfapi/ne-cfapi-cf_callback_delete_completion_flags typedef enum
		// CF_CALLBACK_DELETE_COMPLETION_FLAGS { CF_CALLBACK_DELETE_COMPLETION_FLAG_NONE } ;
		[PInvokeData("cfapi.h", MSDNShortId = "33971B32-C97B-4C79-B6ED-B2E1C20B912A")]
		[Flags]
		public enum CF_CALLBACK_DELETE_COMPLETION_FLAGS
		{
			/// <summary>No delete completion flag.</summary>
			CF_CALLBACK_DELETE_COMPLETION_FLAG_NONE = 0,
		}

		/// <summary>
		/// This callback is used to inform the sync provider that a placeholder file or directory under one of its sync roots is about to
		/// be deleted.
		/// </summary>
		// https://docs.microsoft.com/en-us/windows/win32/api/cfapi/ne-cfapi-cf_callback_delete_flags typedef enum CF_CALLBACK_DELETE_FLAGS
		// { CF_CALLBACK_DELETE_FLAG_NONE, CF_CALLBACK_DELETE_FLAG_IS_DIRECTORY } ;
		[PInvokeData("cfapi.h", MSDNShortId = "76F9FB0C-F531-447F-8F0E-1EB849336771")]
		[Flags]
		public enum CF_CALLBACK_DELETE_FLAGS
		{
			/// <summary>No delete flag.</summary>
			CF_CALLBACK_DELETE_FLAG_NONE = 0,

			/// <summary>The placeholder that is about to be deleted is a directory.</summary>
			CF_CALLBACK_DELETE_FLAG_IS_DIRECTORY = 1,
		}

		/// <summary>Callback flags for fetching data for a placeholder file or folder.</summary>
		// https://docs.microsoft.com/en-us/windows/win32/api/cfapi/ne-cfapi-cf_callback_fetch_data_flags typedef enum
		// CF_CALLBACK_FETCH_DATA_FLAGS { CF_CALLBACK_FETCH_DATA_FLAG_NONE, CF_CALLBACK_FETCH_DATA_FLAG_RECOVERY,
		// CF_CALLBACK_FETCH_DATA_FLAG_EXPLICIT_HYDRATION } ;
		[PInvokeData("cfapi.h", MSDNShortId = "18C2CF8D-C59F-4181-953E-84B6BEC5F479")]
		[Flags]
		public enum CF_CALLBACK_FETCH_DATA_FLAGS
		{
			/// <summary>No data fetch flag.</summary>
			CF_CALLBACK_FETCH_DATA_FLAG_NONE = 0,

			/// <summary>Flag to be used if the callback is invoked as a result of previously interrupted hydration process.</summary>
			CF_CALLBACK_FETCH_DATA_FLAG_RECOVERY = 1,

			/// <summary>
			/// Note This value is new for Windows 10, version 1803. Flag to be used if the callback is invoked as a result of a call to CfHydratePlaceholder.
			/// </summary>
			CF_CALLBACK_FETCH_DATA_FLAG_EXPLICIT_HYDRATION = 2,
		}

		/// <summary>Flags for fetching information about the content of a placeholder file or directory.</summary>
		// https://docs.microsoft.com/en-us/windows/win32/api/cfapi/ne-cfapi-cf_callback_fetch_placeholders_flags typedef enum
		// CF_CALLBACK_FETCH_PLACEHOLDERS_FLAGS { CF_CALLBACK_FETCH_PLACEHOLDERS_FLAG_NONE } ;
		[PInvokeData("cfapi.h", MSDNShortId = "CD90EB49-8C39-49DD-8688-CBDF77B1EA92")]
		[Flags]
		public enum CF_CALLBACK_FETCH_PLACEHOLDERS_FLAGS
		{
			/// <summary>No fetch placeholder flags.</summary>
			CF_CALLBACK_FETCH_PLACEHOLDERS_FLAG_NONE = 0,
		}

		/// <summary>Callback flags for notifying a sync provider that a placeholder was successfully opened for read/write/delete access.</summary>
		// https://docs.microsoft.com/en-us/windows/win32/api/cfapi/ne-cfapi-cf_callback_open_completion_flags typedef enum
		// CF_CALLBACK_OPEN_COMPLETION_FLAGS { CF_CALLBACK_OPEN_COMPLETION_FLAG_NONE, CF_CALLBACK_OPEN_COMPLETION_FLAG_PLACEHOLDER_UNKNOWN,
		// CF_CALLBACK_OPEN_COMPLETION_FLAG_PLACEHOLDER_UNSUPPORTED } ;
		[PInvokeData("cfapi.h", MSDNShortId = "FF7EA010-B90A-46F8-A373-5C128B31FE70")]
		[Flags]
		public enum CF_CALLBACK_OPEN_COMPLETION_FLAGS
		{
			/// <summary>No open completion flag.</summary>
			CF_CALLBACK_OPEN_COMPLETION_FLAG_NONE = 0,

			/// <summary>A flag set if the placeholder metadata is corrupted.</summary>
			CF_CALLBACK_OPEN_COMPLETION_FLAG_PLACEHOLDER_UNKNOWN = 1,

			/// <summary>A flag set if the placeholder metadata is not supported.</summary>
			CF_CALLBACK_OPEN_COMPLETION_FLAG_PLACEHOLDER_UNSUPPORTED = 2,
		}

		/// <summary>
		/// A callback flag to inform the sync provider that a placeholder under one of its sync roots has been successfully renamed.
		/// </summary>
		// https://docs.microsoft.com/en-us/windows/win32/api/cfapi/ne-cfapi-cf_callback_rename_completion_flags typedef enum
		// CF_CALLBACK_RENAME_COMPLETION_FLAGS { CF_CALLBACK_RENAME_COMPLETION_FLAG_NONE } ;
		[PInvokeData("cfapi.h", MSDNShortId = "60C94543-E0C4-4A79-BBE3-3098401B1123")]
		[Flags]
		public enum CF_CALLBACK_RENAME_COMPLETION_FLAGS
		{
			/// <summary>No rename completion flag.</summary>
			CF_CALLBACK_RENAME_COMPLETION_FLAG_NONE = 0,
		}

		/// <summary>
		/// Call back flags to inform the sync provider that a placeholder under one of its sync roots is about to be renamed or moved.
		/// </summary>
		// https://docs.microsoft.com/en-us/windows/win32/api/cfapi/ne-cfapi-cf_callback_rename_flags typedef enum CF_CALLBACK_RENAME_FLAGS
		// { CF_CALLBACK_RENAME_FLAG_NONE, CF_CALLBACK_RENAME_FLAG_IS_DIRECTORY, CF_CALLBACK_RENAME_FLAG_SOURCE_IN_SCOPE,
		// CF_CALLBACK_RENAME_FLAG_TARGET_IN_SCOPE } ;
		[PInvokeData("cfapi.h", MSDNShortId = "7506ED1D-F6A8-49EB-B03B-B629264DFBB2")]
		[Flags]
		public enum CF_CALLBACK_RENAME_FLAGS
		{
			/// <summary>No rename flag.</summary>
			CF_CALLBACK_RENAME_FLAG_NONE = 0,

			/// <summary>Flag set if the placeholder is a directory.</summary>
			CF_CALLBACK_RENAME_FLAG_IS_DIRECTORY = 1,

			/// <summary>Flag set if the link to be renamed or moved is within a sync root managed by the sync process.</summary>
			CF_CALLBACK_RENAME_FLAG_SOURCE_IN_SCOPE = 2,

			/// <summary>Flag set if the rename or move target is in the same sync root of the source path.</summary>
			CF_CALLBACK_RENAME_FLAG_TARGET_IN_SCOPE = 4,
		}

		/// <summary>Contains the various types of callbacks used on placeholder files or folders.</summary>
		/// <remarks>
		/// <para>
		/// These are not APIs provided by the library, but rather callbacks that a sync provider must implement in order to service
		/// requests from the platform. As necessary, the platform will ask the library instance running inside the sync provider process to
		/// invoke the appropriate callback routine.
		/// </para>
		/// <para>
		/// Callback routines will be invoked in an arbitrary thread (part of a thread pool). Multiple callbacks can occur simultaneously,
		/// in different threads, and it is the responsibility of the sync provider code to implement any necessary synchronization to make
		/// this work reliably. All callbacks are asynchronous. Asynchronous user requests that trigger the callbacks are pended and the
		/// control is returned to the user application.
		/// </para>
		/// <para>
		/// Every callback request has a fixed 60 second timeout. A valid operation on any pending requests from the sync provider resets
		/// the timers of all pending requests.
		/// </para>
		/// <para>
		/// All callback functions have the same prototype with two arguments: a CF_CALLBACK_INFO structure and a CF_CALLBACK_PARAMETER structure.
		/// </para>
		/// <para>Callback routines have no return value.</para>
		/// </remarks>
		// https://docs.microsoft.com/en-us/windows/win32/api/cfapi/ne-cfapi-cf_callback_type typedef enum CF_CALLBACK_TYPE {
		// CF_CALLBACK_TYPE_FETCH_DATA, CF_CALLBACK_TYPE_VALIDATE_DATA, CF_CALLBACK_TYPE_CANCEL_FETCH_DATA,
		// CF_CALLBACK_TYPE_FETCH_PLACEHOLDERS, CF_CALLBACK_TYPE_CANCEL_FETCH_PLACEHOLDERS, CF_CALLBACK_TYPE_NOTIFY_FILE_OPEN_COMPLETION,
		// CF_CALLBACK_TYPE_NOTIFY_FILE_CLOSE_COMPLETION, CF_CALLBACK_TYPE_NOTIFY_DEHYDRATE, CF_CALLBACK_TYPE_NOTIFY_DEHYDRATE_COMPLETION,
		// CF_CALLBACK_TYPE_NOTIFY_DELETE, CF_CALLBACK_TYPE_NOTIFY_DELETE_COMPLETION, CF_CALLBACK_TYPE_NOTIFY_RENAME,
		// CF_CALLBACK_TYPE_NOTIFY_RENAME_COMPLETION, CF_CALLBACK_TYPE_NONE } ;
		[PInvokeData("cfapi.h", MSDNShortId = "0BA978D3-110C-47FC-8949-C5D98A59654C")]
		[Flags]
		public enum CF_CALLBACK_TYPE : uint
		{
			/// <summary>Callback to satisfy an I/O request, or a placeholder hydration request.</summary>
			CF_CALLBACK_TYPE_FETCH_DATA,

			/// <summary>Callback to validate placeholder data.</summary>
			CF_CALLBACK_TYPE_VALIDATE_DATA,

			/// <summary>Callback to cancel an ongoing placeholder hydration.</summary>
			CF_CALLBACK_TYPE_CANCEL_FETCH_DATA,

			/// <summary>Callback to request information about the contents of placeholder files.</summary>
			CF_CALLBACK_TYPE_FETCH_PLACEHOLDERS,

			/// <summary>Callback to cancel a request for the contents of placeholder files.</summary>
			CF_CALLBACK_TYPE_CANCEL_FETCH_PLACEHOLDERS,

			/// <summary>
			/// Callback to inform the sync provider that a placeholder under one of its sync roots has been successfully opened for
			/// read/write/delete access.
			/// </summary>
			CF_CALLBACK_TYPE_NOTIFY_FILE_OPEN_COMPLETION,

			/// <summary>
			/// Callback to inform the sync provider that a placeholder under one of its sync roots that has been previously opened for
			/// read/write/delete access is now closed.
			/// </summary>
			CF_CALLBACK_TYPE_NOTIFY_FILE_CLOSE_COMPLETION,

			/// <summary>Callback to inform the sync provider that a placeholder under one of its sync roots is about to be dehydrated.</summary>
			CF_CALLBACK_TYPE_NOTIFY_DEHYDRATE,

			/// <summary>Callback to inform the sync provider that a placeholder under one of its sync roots has been successfully dehydrated.</summary>
			CF_CALLBACK_TYPE_NOTIFY_DEHYDRATE_COMPLETION,

			/// <summary>Callback to inform the sync provider that a placeholder under one of its sync roots is about to be deleted.</summary>
			CF_CALLBACK_TYPE_NOTIFY_DELETE,

			/// <summary>Callback to inform the sync provider that a placeholder under one of its sync roots has been successfully deleted.</summary>
			CF_CALLBACK_TYPE_NOTIFY_DELETE_COMPLETION,

			/// <summary>
			/// Callback to inform the sync provider that a placeholder under one of its sync roots is about to be renamed or moved.
			/// </summary>
			CF_CALLBACK_TYPE_NOTIFY_RENAME,

			/// <summary>
			/// Callback to inform the sync provider that a placeholder under one of its sync roots has been successfully renamed or moved.
			/// </summary>
			CF_CALLBACK_TYPE_NOTIFY_RENAME_COMPLETION,

			/// <summary>No callback type.</summary>
			CF_CALLBACK_TYPE_NONE = 0xffffffff,
		}

		/// <summary>Flags to validate the data of a placeholder file or directory.</summary>
		// https://docs.microsoft.com/en-us/windows/win32/api/cfapi/ne-cfapi-cf_callback_validate_data_flags typedef enum
		// CF_CALLBACK_VALIDATE_DATA_FLAGS { CF_CALLBACK_VALIDATE_DATA_FLAG_NONE, CF_CALLBACK_VALIDATE_DATA_FLAG_EXPLICIT_HYDRATION } ;
		[PInvokeData("cfapi.h", MSDNShortId = "D5BEAEAA-318E-4BA5-8DC5-EDD24E2C26EF")]
		[Flags]
		public enum CF_CALLBACK_VALIDATE_DATA_FLAGS
		{
			/// <summary>No data validation flag.</summary>
			CF_CALLBACK_VALIDATE_DATA_FLAG_NONE = 0,

			/// <summary>
			/// Note This value is new for Windows 10, version 1803.Set if the callback is invoked as a result of a call to CfHydratePlaceholder.
			/// </summary>
			CF_CALLBACK_VALIDATE_DATA_FLAG_EXPLICIT_HYDRATION = 2,
		}

		/// <summary>Additional information that can be requested by a sync provider when its callbacks are invoked.</summary>
		// https://docs.microsoft.com/en-us/windows/win32/api/cfapi/ne-cfapi-cf_connect_flags typedef enum CF_CONNECT_FLAGS {
		// CF_CONNECT_FLAG_NONE, CF_CONNECT_FLAG_REQUIRE_PROCESS_INFO, CF_CONNECT_FLAG_REQUIRE_FULL_FILE_PATH,
		// CF_CONNECT_FLAG_BLOCK_SELF_IMPLICIT_HYDRATION } ;
		[PInvokeData("cfapi.h", MSDNShortId = "C1CAC75C-9CB6-4172-A437-AE366D99DA9F")]
		[Flags]
		public enum CF_CONNECT_FLAGS
		{
			/// <summary>No connection flags.</summary>
			CF_CONNECT_FLAG_NONE = 0,

			/// <summary>
			/// When this flag is specified, the platform returns the full image path of the hydrating process in the callback parameters.
			/// </summary>
			CF_CONNECT_FLAG_REQUIRE_PROCESS_INFO = 2,

			/// <summary>
			/// When this flag is specified, the platform returns the full path of the placeholder being requested in the callback parameters.
			/// </summary>
			CF_CONNECT_FLAG_REQUIRE_FULL_FILE_PATH = 4,

			/// <summary>
			/// Note This value is new for Windows 10, version 1803.When this flag is specified, The implicit hydration, which is not
			/// performed via CfHydratePlaceholder, can happen when the anti-virus software scans a sync provider’s file system activities
			/// on non-hydrated cloud file placeholders. This kind of implicit hydration is not expected. If the sync provider never
			/// initiates implicit hydration operations, it can instruct the platform to block all such implicit hydration operations, as
			/// opposed to failing the FETCH_DATA callbacks later.
			/// </summary>
			CF_CONNECT_FLAG_BLOCK_SELF_IMPLICIT_HYDRATION = 8,
		}

		/// <summary>Normal file/directory to placeholder file/directory conversion flags.</summary>
		// https://docs.microsoft.com/en-us/windows/win32/api/cfapi/ne-cfapi-cf_convert_flags typedef enum CF_CONVERT_FLAGS {
		// CF_CONVERT_FLAG_NONE, CF_CONVERT_FLAG_MARK_IN_SYNC, CF_CONVERT_FLAG_DEHYDRATE, CF_CONVERT_FLAG_ENABLE_ON_DEMAND_POPULATION } ;
		[PInvokeData("cfapi.h", MSDNShortId = "0342BF0B-509A-4F8D-9557-54E534A3DDFE")]
		[Flags]
		public enum CF_CONVERT_FLAGS
		{
			/// <summary>No conversion flags.</summary>
			CF_CONVERT_FLAG_NONE = 0,

			/// <summary>The platform marks the converted placeholder as in sync with cloud upon a successful conversion of the file.</summary>
			CF_CONVERT_FLAG_MARK_IN_SYNC = 1,

			/// <summary>
			/// Applicable to files only. When specified, the platform dehydrates the file after converting it to a placeholder
			/// successfully. The caller must acquire an exclusive handle when specifying this flag or data corruptions can occur. Note that
			/// the platform does not validate the exclusiveness of the handle.
			/// </summary>
			CF_CONVERT_FLAG_DEHYDRATE = 2,

			/// <summary>
			/// Applicable for directories only. When specified, it marks the converted placeholder directory as partially populated such
			/// that any future access to it will result in a FETCH_PLACEHOLDERS callback sent to the sync provider.
			/// </summary>
			CF_CONVERT_FLAG_ENABLE_ON_DEMAND_POPULATION = 4,
		}

		/// <summary>Flags for creating a placeholder file or directory.</summary>
		// https://docs.microsoft.com/en-us/windows/win32/api/cfapi/ne-cfapi-cf_create_flags typedef enum CF_CREATE_FLAGS {
		// CF_CREATE_FLAG_NONE, CF_CREATE_FLAG_STOP_ON_ERROR } ;
		[PInvokeData("cfapi.h", MSDNShortId = "F70ECFDB-8542-4395-9EDD-7DABC2E5225D")]
		[Flags]
		public enum CF_CREATE_FLAGS
		{
			/// <summary>Default mode. All entries are processed.</summary>
			CF_CREATE_FLAG_NONE = 0,

			/// <summary>
			/// Causes the API to return immediately if placeholder creation fails. If creation fails, the error code will be returned by
			/// the API.
			/// </summary>
			CF_CREATE_FLAG_STOP_ON_ERROR = 1,
		}

		/// <summary>Placeholder dehydration flags.</summary>
		// https://docs.microsoft.com/en-us/windows/win32/api/cfapi/ne-cfapi-cf_dehydrate_flags typedef enum CF_DEHYDRATE_FLAGS {
		// CF_DEHYDRATE_FLAG_NONE, CF_DEHYDRATE_FLAG_BACKGROUND } ;
		[PInvokeData("cfapi.h", MSDNShortId = "AE8AA67D-F6ED-4A2B-8613-17BBAB4C9F54")]
		[Flags]
		public enum CF_DEHYDRATE_FLAGS
		{
			/// <summary>No dehydration flags.</summary>
			CF_DEHYDRATE_FLAG_NONE = 0,

			/// <summary>
			/// If specified, the caller is a system process running in the background. Otherwise, the caller is performing this operation
			/// on behalf of a logged-in user.
			/// </summary>
			CF_DEHYDRATE_FLAG_BACKGROUND = 1,
		}

		/// <summary>Specifies whether or not hard links are allowed on placeholder files.</summary>
		/// <remarks>
		/// If hard links are enabled, applications can create as many hard links as the file system supports so long as the links are under
		/// the same sync root or no sync root. Hard links and placeholder operations that are not compatible with this policy will fail
		/// with the error: HRESULT(ERROR_CLOUD_FILES_INCOMPATIBLE_HARDLINKS).
		/// </remarks>
		// https://docs.microsoft.com/en-us/windows/win32/api/cfapi/ne-cfapi-cf_hardlink_policy typedef enum CF_HARDLINK_POLICY {
		// CF_HARDLINK_POLICY_NONE, CF_HARDLINK_POLICY_ALLOWED } ;
		[PInvokeData("cfapi.h", MSDNShortId = "23FFC4E8-0CB7-4FF4-A3C3-2E8FB2C74497")]
		[Flags]
		public enum CF_HARDLINK_POLICY
		{
			/// <summary/>
			CF_HARDLINK_POLICY_NONE = 0,

			/// <summary>Hard links can be created on a placeholder under the same sync root or no sync root.</summary>
			CF_HARDLINK_POLICY_ALLOWED = 1,
		}

		/// <summary>Placeholder data hydration flags.</summary>
		// https://docs.microsoft.com/en-us/windows/win32/api/cfapi/ne-cfapi-cf_hydrate_flags typedef enum CF_HYDRATE_FLAGS {
		// CF_HYDRATE_FLAG_NONE } ;
		[PInvokeData("cfapi.h", MSDNShortId = "1D49752C-2D80-4EC8-AE24-2DEAFCB7FD46")]
		[Flags]
		public enum CF_HYDRATE_FLAGS
		{
			/// <summary>No hydration flags.</summary>
			CF_HYDRATE_FLAG_NONE = 0,
		}

		/// <summary>
		/// Allows a sync provider to control how placeholder files should be hydrated by the platform. This is a modifier that can be used
		/// with the primary policy: CF_HYDRATION_POLICY_PRIMARY.
		/// </summary>
		/// <remarks>
		/// In general, modifiers can be mixed and matched with any primary policy (CF_HYDRATION_POLICY_PRIMARY) and other policy modifiers
		/// so long as the combination is not self-conflicting.
		/// </remarks>
		// https://docs.microsoft.com/en-us/windows/win32/api/cfapi/ne-cfapi-cf_hydration_policy_modifier typedef enum
		// CF_HYDRATION_POLICY_MODIFIER { CF_HYDRATION_POLICY_MODIFIER_NONE, CF_HYDRATION_POLICY_MODIFIER_VALIDATION_REQUIRED,
		// CF_HYDRATION_POLICY_MODIFIER_STREAMING_ALLOWED, CF_HYDRATION_POLICY_MODIFIER_AUTO_DEHYDRATION_ALLOWED } ;
		[PInvokeData("cfapi.h", MSDNShortId = "A98C635E-7E18-4E18-B19A-D3FD85A53CBB")]
		[Flags]
		public enum CF_HYDRATION_POLICY_MODIFIER : ushort
		{
			/// <summary>No policy modifier.</summary>
			CF_HYDRATION_POLICY_MODIFIER_NONE = 0,

			/// <summary>
			/// This policy modifier offers two guarantees to a sync provider. First, it guarantees that the data returned by the sync
			/// provider is always persisted to the disk prior to it being returned to the user application. Second, it allows the sync
			/// provider to retrieve the same data it has returned previously to the platform and validate its integrity. Only upon a
			/// successful confirmation of the integrity by the sync provider will the platform complete the user I/O request. This modifier
			/// helps support end-to-end data integrity at the cost of extra disk I/Os.
			/// </summary>
			CF_HYDRATION_POLICY_MODIFIER_VALIDATION_REQUIRED = 1,

			/// <summary>
			/// This policy modifier grants the platform the permission to not store any data returned by a sync provider on local disks.
			/// This policy modifier is ineffective when being combined with CF_HYDRATION_POLICY_MODIFIER_VALIDATION_REQUIRED.
			/// </summary>
			CF_HYDRATION_POLICY_MODIFIER_STREAMING_ALLOWED = 2,

			/// <summary>
			/// Note This value is new for Windows 10, version 1803.This policy modifier grants the platform the permission to dehydrate
			/// in-sync cloud file placeholders without the help of sync providers. Without this flag, the platform is not allowed to call
			/// CfDehydratePlaceholder directly. Instead, the only supported way to dehydrate a cloud file placeholder is to clear the
			/// file’s pinned attribute and set the file’s unpinned attribute. At that point, the actual dehydration will be performed
			/// asynchronously by the sync engine after it receives the directory change notification on the two attributes. When this flag
			/// is specified, the platform will be allowed to invoke CfDehydratePlaceholder directly on any in-sync cloud file placeholder.
			/// It is recommended for sync providers to support auto-dehydration.
			/// </summary>
			CF_HYDRATION_POLICY_MODIFIER_AUTO_DEHYDRATION_ALLOWED = 4,
		}

		/// <summary>
		/// Allows a sync provider to control how placeholder files should be hydrated by the platform. This is the primary policy.
		/// </summary>
		// https://docs.microsoft.com/en-us/windows/win32/api/cfapi/ne-cfapi-cf_hydration_policy_primary typedef enum
		// CF_HYDRATION_POLICY_PRIMARY { CF_HYDRATION_POLICY_PARTIAL, CF_HYDRATION_POLICY_PROGRESSIVE, CF_HYDRATION_POLICY_FULL,
		// CF_HYDRATION_POLICY_ALWAYS_FULL } ;
		[PInvokeData("cfapi.h", MSDNShortId = "47ACA107-80AA-42B3-B583-399323E2B11C")]
		public enum CF_HYDRATION_POLICY_PRIMARY : ushort
		{
			/// <summary>
			/// The same behavior as CF_HYDRATION_POLICY_PROGRESSIVE, except that CF_HYDRATION_POLICY_PARTIAL does not have continuous
			/// hydration in the background.
			/// </summary>
			CF_HYDRATION_POLICY_PARTIAL,

			/// <summary>
			/// When CF_HYDRATION_POLICY_PROGRESSIVE is selected, the platform will allow a placeholder to be dehydrated. When the platform
			/// detects access to a dehydrated placeholder, it will complete the user IO request as soon as it determines that sufficient
			/// data is received from the sync provider. However, the platform will continue requesting the remaining content in the
			/// placeholder from the sync provider in the background until either the full content of the placeholder is available locally,
			/// or the last user handle on the placeholder is closed.
			/// </summary>
			CF_HYDRATION_POLICY_PROGRESSIVE,

			/// <summary>
			/// When CF_HYDRATION_POLICY_FULL is selected, the platform will allow a placeholder to be dehydrated. When the platform detects
			/// access to a dehydrated placeholder, it will ensure that the full content of the placeholder is available locally before
			/// completing the user IO request, even if the request is only asking for 1 byte.
			/// </summary>
			CF_HYDRATION_POLICY_FULL,

			/// <summary>
			/// When CF_HYDRATION_POLICY_ALWAYS_FULL is selected, the platform will block any placeholder operation that could result in a
			/// not fully hydrated placeholder, which includes CfCreatePlaceholders, CfUpdatePlaceholder with the dehydrate option, and
			/// CfConvertToPlaceholder with the dehydrate option.
			/// </summary>
			CF_HYDRATION_POLICY_ALWAYS_FULL,
		}

		/// <summary>Specifies the in-sync state for placeholder files and folders.</summary>
		// https://docs.microsoft.com/en-us/windows/win32/api/cfapi/ne-cfapi-cf_in_sync_state typedef enum CF_IN_SYNC_STATE {
		// CF_IN_SYNC_STATE_NOT_IN_SYNC, CF_IN_SYNC_STATE_IN_SYNC } ;
		[PInvokeData("cfapi.h", MSDNShortId = "05F99E47-00EE-422C-BDDF-CCCDDD4DADED")]
		public enum CF_IN_SYNC_STATE
		{
			/// <summary>The platform clears the placeholder’s in-sync state upon a successful return from the CfSetInSyncState call.</summary>
			CF_IN_SYNC_STATE_NOT_IN_SYNC,

			/// <summary>The platform sets the placeholder’s in-sync state upon a successful return from the CfSetInSyncState call.</summary>
			CF_IN_SYNC_STATE_IN_SYNC,
		}

		/// <summary>
		/// A policy allowing a sync provider to control when the platform should clear the in-sync state on a placeholder file or directory.
		/// </summary>
		// https://docs.microsoft.com/en-us/windows/win32/api/cfapi/ne-cfapi-cf_insync_policy typedef enum CF_INSYNC_POLICY {
		// CF_INSYNC_POLICY_NONE, CF_INSYNC_POLICY_TRACK_FILE_CREATION_TIME, CF_INSYNC_POLICY_TRACK_FILE_READONLY_ATTRIBUTE,
		// CF_INSYNC_POLICY_TRACK_FILE_HIDDEN_ATTRIBUTE, CF_INSYNC_POLICY_TRACK_FILE_SYSTEM_ATTRIBUTE,
		// CF_INSYNC_POLICY_TRACK_DIRECTORY_CREATION_TIME, CF_INSYNC_POLICY_TRACK_DIRECTORY_READONLY_ATTRIBUTE,
		// CF_INSYNC_POLICY_TRACK_DIRECTORY_HIDDEN_ATTRIBUTE, CF_INSYNC_POLICY_TRACK_DIRECTORY_SYSTEM_ATTRIBUTE,
		// CF_INSYNC_POLICY_TRACK_FILE_LAST_WRITE_TIME, CF_INSYNC_POLICY_TRACK_DIRECTORY_LAST_WRITE_TIME, CF_INSYNC_POLICY_TRACK_FILE_ALL,
		// CF_INSYNC_POLICY_TRACK_DIRECTORY_ALL, CF_INSYNC_POLICY_TRACK_ALL, CF_INSYNC_POLICY_PRESERVE_INSYNC_FOR_SYNC_ENGINE } ;
		[PInvokeData("cfapi.h", MSDNShortId = "BE9574D7-2717-42F6-AB59-096AACCD8BC1")]
		[Flags]
		public enum CF_INSYNC_POLICY : uint
		{
			/// <summary/>
			CF_INSYNC_POLICY_NONE = 0x00000000,

			/// <summary>Clears in-sync state when a file is created.</summary>
			CF_INSYNC_POLICY_TRACK_FILE_CREATION_TIME = 0x00000001,

			/// <summary>Clears in-sync state when a file is read-only.</summary>
			CF_INSYNC_POLICY_TRACK_FILE_READONLY_ATTRIBUTE = 0x00000002,

			/// <summary>Clears in-sync state when a file is hidden.</summary>
			CF_INSYNC_POLICY_TRACK_FILE_HIDDEN_ATTRIBUTE = 0x00000004,

			/// <summary/>
			CF_INSYNC_POLICY_TRACK_FILE_SYSTEM_ATTRIBUTE = 0x00000008,

			/// <summary>Clears in-sync state when a directory is created.</summary>
			CF_INSYNC_POLICY_TRACK_DIRECTORY_CREATION_TIME = 0x00000010,

			/// <summary>Clears in-sync state when a directory is read-only.</summary>
			CF_INSYNC_POLICY_TRACK_DIRECTORY_READONLY_ATTRIBUTE = 0x00000020,

			/// <summary>Clears in-sync state when a directory is hidden.</summary>
			CF_INSYNC_POLICY_TRACK_DIRECTORY_HIDDEN_ATTRIBUTE = 0x00000040,

			/// <summary>Clears in-sync state when a directory is a system directory.</summary>
			CF_INSYNC_POLICY_TRACK_DIRECTORY_SYSTEM_ATTRIBUTE = 0x00000080,

			/// <summary>Clears in-sync state based on the last write time to a file.</summary>
			CF_INSYNC_POLICY_TRACK_FILE_LAST_WRITE_TIME = 0x00000100,

			/// <summary>Clears in-sync state based on the last write time to a directory.</summary>
			CF_INSYNC_POLICY_TRACK_DIRECTORY_LAST_WRITE_TIME = 0x00000200,

			/// <summary>Clears in-sync state for any changes to a file.</summary>
			CF_INSYNC_POLICY_TRACK_FILE_ALL = 0x0055550f,

			/// <summary>Clears in-sync state for any changes to a directory.</summary>
			CF_INSYNC_POLICY_TRACK_DIRECTORY_ALL = 0x00aaaaf0,

			/// <summary>Clears in-sync state for any changes to a file or directory.</summary>
			CF_INSYNC_POLICY_TRACK_ALL = 0x00ffffff,

			/// <summary>In-sync policies are exempt from clearing.</summary>
			CF_INSYNC_POLICY_PRESERVE_INSYNC_FOR_SYNC_ENGINE = 0x80000000,
		}

		/// <summary>Flags to request various permissions on opening a file.</summary>
		// https://docs.microsoft.com/en-us/windows/win32/api/cfapi/ne-cfapi-cf_open_file_flags typedef enum CF_OPEN_FILE_FLAGS {
		// CF_OPEN_FILE_FLAG_NONE, CF_OPEN_FILE_FLAG_EXCLUSIVE, CF_OPEN_FILE_FLAG_WRITE_ACCESS, CF_OPEN_FILE_FLAG_DELETE_ACCESS,
		// CF_OPEN_FILE_FLAG_FOREGROUND } ;
		[PInvokeData("cfapi.h", MSDNShortId = "4A9D87AB-7B81-46DF-80C3-DB2F63C76964")]
		[Flags]
		public enum CF_OPEN_FILE_FLAGS
		{
			/// <summary>No open file flags.</summary>
			CF_OPEN_FILE_FLAG_NONE = 0,

			/// <summary>When specified, CfOpenFileWithOplock returns a share-none handle and requests an RH (OPLOCK_LEVEL_CACHE_READ</summary>
			CF_OPEN_FILE_FLAG_EXCLUSIVE = 1,

			/// <summary>
			/// When specified, CfOpenFileWithOplock attempts to open the file or directory with FILE_READ_DATA/FILE_LIST_DIRECTORY and
			/// FILE_WRITE_DATA/FILE_ADD_FILE access; otherwise it attempts to open the file or directory with FILE_READ_DATA/ FILE_LIST_DIRECTORY.
			/// </summary>
			CF_OPEN_FILE_FLAG_WRITE_ACCESS = 2,

			/// <summary>
			/// When specified, CfOpenFileWithOplock attempts to open the file or directory with DELETE access; otherwise it opens the file normally.
			/// </summary>
			CF_OPEN_FILE_FLAG_DELETE_ACCESS = 4,

			/// <summary/>
			CF_OPEN_FILE_FLAG_FOREGROUND = 8,
		}

		/// <summary>Flags to verify and acknowledge data for a placeholder file or folder.</summary>
		// https://docs.microsoft.com/en-us/windows/win32/api/cfapi/ne-cfapi-cf_operation_ack_data_flags typedef enum
		// CF_OPERATION_ACK_DATA_FLAGS { CF_OPERATION_ACK_DATA_FLAG_NONE } ;
		[PInvokeData("cfapi.h", MSDNShortId = "9465B686-7C8A-44AD-BC65-41F22FFEC741")]
		[Flags]
		public enum CF_OPERATION_ACK_DATA_FLAGS
		{
			/// <summary>No acknowledge data flag.</summary>
			CF_OPERATION_ACK_DATA_FLAG_NONE = 0,
		}

		/// <summary>Flags to acknowledge the dehydration of a placeholder file or directory.</summary>
		// https://docs.microsoft.com/en-us/windows/win32/api/cfapi/ne-cfapi-cf_operation_ack_dehydrate_flags typedef enum
		// CF_OPERATION_ACK_DEHYDRATE_FLAGS { CF_OPERATION_ACK_DEHYDRATE_FLAG_NONE } ;
		[PInvokeData("cfapi.h", MSDNShortId = "A1236139-947A-4360-91A0-E634A22C26A5")]
		[Flags]
		public enum CF_OPERATION_ACK_DEHYDRATE_FLAGS
		{
			/// <summary>No acknowledge dehydration flag.</summary>
			CF_OPERATION_ACK_DEHYDRATE_FLAG_NONE = 0,
		}

		/// <summary>Flags to acknowledge the deletion of a placeholder file or directory.</summary>
		// https://docs.microsoft.com/en-us/windows/win32/api/cfapi/ne-cfapi-cf_operation_ack_delete_flags typedef enum
		// CF_OPERATION_ACK_DELETE_FLAGS { CF_OPERATION_ACK_DELETE_FLAG_NONE } ;
		[PInvokeData("cfapi.h", MSDNShortId = "407B7035-09A0-43BC-AC07-2CC0973DDBCC")]
		[Flags]
		public enum CF_OPERATION_ACK_DELETE_FLAGS
		{
			/// <summary>No deletion acknowledgment flags.</summary>
			CF_OPERATION_ACK_DELETE_FLAG_NONE = 0,
		}

		/// <summary>Flags for acknowledging placeholder file or directory renaming.</summary>
		// https://docs.microsoft.com/en-us/windows/win32/api/cfapi/ne-cfapi-cf_operation_ack_rename_flags typedef enum
		// CF_OPERATION_ACK_RENAME_FLAGS { CF_OPERATION_ACK_RENAME_FLAG_NONE } ;
		[PInvokeData("cfapi.h", MSDNShortId = "2EAABBAE-8737-4399-8C39-7D63B45C52B3")]
		[Flags]
		public enum CF_OPERATION_ACK_RENAME_FLAGS
		{
			/// <summary>No acknowledgment of placeholder renaming.</summary>
			CF_OPERATION_ACK_RENAME_FLAG_NONE = 0,
		}

		/// <summary>Flags to restart data hydration on a placeholder file or folder.</summary>
		// https://docs.microsoft.com/en-us/windows/win32/api/cfapi/ne-cfapi-cf_operation_restart_hydration_flags typedef enum
		// CF_OPERATION_RESTART_HYDRATION_FLAGS { CF_OPERATION_RESTART_HYDRATION_FLAG_NONE, CF_OPERATION_RESTART_HYDRATION_FLAG_MARK_IN_SYNC
		// } ;
		[PInvokeData("cfapi.h", MSDNShortId = "4112937A-3ED6-48F8-BFD1-52D01ABA3D72")]
		[Flags]
		public enum CF_OPERATION_RESTART_HYDRATION_FLAGS
		{
			/// <summary>No restart data hydration flag.</summary>
			CF_OPERATION_RESTART_HYDRATION_FLAG_NONE = 0,

			/// <summary>If this flag is specified, the placeholder will be marked in-sync upon a successful RESTART_HYDRATION operation.</summary>
			CF_OPERATION_RESTART_HYDRATION_FLAG_MARK_IN_SYNC = 1,
		}

		/// <summary>Flags to retrieve data for a placeholder file or folder.</summary>
		// https://docs.microsoft.com/en-us/windows/win32/api/cfapi/ne-cfapi-cf_operation_retrieve_data_flags typedef enum
		// CF_OPERATION_RETRIEVE_DATA_FLAGS { CF_OPERATION_RETRIEVE_DATA_FLAG_NONE } ;
		[PInvokeData("cfapi.h", MSDNShortId = "A233B2E8-B350-495A-9688-3795790F23EF")]
		[Flags]
		public enum CF_OPERATION_RETRIEVE_DATA_FLAGS
		{
			/// <summary>No retrieve data flag.</summary>
			CF_OPERATION_RETRIEVE_DATA_FLAG_NONE = 0,
		}

		/// <summary>Flags to transfer data to hydrate a placeholder file or folder.</summary>
		// https://docs.microsoft.com/en-us/windows/win32/api/cfapi/ne-cfapi-cf_operation_transfer_data_flags typedef enum
		// CF_OPERATION_TRANSFER_DATA_FLAGS { CF_OPERATION_TRANSFER_DATA_FLAG_NONE } ;
		[PInvokeData("cfapi.h", MSDNShortId = "6273CB7A-80B9-4E9A-8C3A-5308F59BB335")]
		[Flags]
		public enum CF_OPERATION_TRANSFER_DATA_FLAGS
		{
			/// <summary>No transfer data flag.</summary>
			CF_OPERATION_TRANSFER_DATA_FLAG_NONE = 0,
		}

		/// <summary>Flags to specify the behavior when transferring a placeholder file or directory.</summary>
		// https://docs.microsoft.com/en-us/windows/win32/api/cfapi/ne-cfapi-cf_operation_transfer_placeholders_flags typedef enum
		// CF_OPERATION_TRANSFER_PLACEHOLDERS_FLAGS { CF_OPERATION_TRANSFER_PLACEHOLDERS_FLAG_NONE,
		// CF_OPERATION_TRANSFER_PLACEHOLDERS_FLAG_STOP_ON_ERROR, CF_OPERATION_TRANSFER_PLACEHOLDERS_FLAG_DISABLE_ON_DEMAND_POPULATION } ;
		[PInvokeData("cfapi.h", MSDNShortId = "6C75030D-A5CF-423D-A931-3D2ED6113BD1")]
		[Flags]
		public enum CF_OPERATION_TRANSFER_PLACEHOLDERS_FLAGS
		{
			/// <summary>No transfer placeholder flags.</summary>
			CF_OPERATION_TRANSFER_PLACEHOLDERS_FLAG_NONE = 0,

			/// <summary>
			/// Causes the API to return immediately if a placeholder transfer fails. If a transfer fails, the error code will be returned.
			/// </summary>
			CF_OPERATION_TRANSFER_PLACEHOLDERS_FLAG_STOP_ON_ERROR = 1,

			/// <summary>
			/// The transferred child placeholder directory is considered to have all of its children present locally.Applicable to a child
			/// placeholder directory only.
			/// </summary>
			CF_OPERATION_TRANSFER_PLACEHOLDERS_FLAG_DISABLE_ON_DEMAND_POPULATION = 2,
		}

		/// <summary>The types of operations that can be performed on placeholder files and directories.</summary>
		// https://docs.microsoft.com/en-us/windows/win32/api/cfapi/ne-cfapi-cf_operation_type typedef enum CF_OPERATION_TYPE {
		// CF_OPERATION_TYPE_TRANSFER_DATA, CF_OPERATION_TYPE_RETRIEVE_DATA, CF_OPERATION_TYPE_ACK_DATA,
		// CF_OPERATION_TYPE_RESTART_HYDRATION, CF_OPERATION_TYPE_TRANSFER_PLACEHOLDERS, CF_OPERATION_TYPE_ACK_DEHYDRATE,
		// CF_OPERATION_TYPE_ACK_DELETE, CF_OPERATION_TYPE_ACK_RENAME } ;
		[PInvokeData("cfapi.h", MSDNShortId = "34E23442-1BCC-4B8B-9AD3-67B2AEDBE2FE")]
		public enum CF_OPERATION_TYPE
		{
			/// <summary>Transfers data to hydrate a placeholder.</summary>
			CF_OPERATION_TYPE_TRANSFER_DATA,

			/// <summary>Validates the integrity of data previously transferred to a placeholder.</summary>
			CF_OPERATION_TYPE_RETRIEVE_DATA,

			/// <summary>Data is acknowledged by the sync provider.</summary>
			CF_OPERATION_TYPE_ACK_DATA,

			/// <summary>Restarts ongoing data hydration.</summary>
			CF_OPERATION_TYPE_RESTART_HYDRATION,

			/// <summary>Transfers placeholders.</summary>
			CF_OPERATION_TYPE_TRANSFER_PLACEHOLDERS,

			/// <summary>Acknowledge and dehydrate a placeholder.</summary>
			CF_OPERATION_TYPE_ACK_DEHYDRATE,

			/// <summary>Acknowledge and delete a placeholder.</summary>
			CF_OPERATION_TYPE_ACK_DELETE,

			/// <summary>Acknowledge and rename a placeholder.</summary>
			CF_OPERATION_TYPE_ACK_RENAME,
		}

		/// <summary>Pin states of a placeholder file or directory.</summary>
		/// <remarks>
		/// <list type="table">
		/// <listheader>
		/// <term/>
		/// <term>Parent</term>
		/// <term>Unspecified</term>
		/// <term>Pinned</term>
		/// <term>Unpinned</term>
		/// <term>Excluded</term>
		/// </listheader>
		/// <item>
		/// <term>File</term>
		/// <term>Unspecified</term>
		/// <term>Unspecified</term>
		/// <term>Pinned</term>
		/// <term>Unspecified</term>
		/// <term>Excluded</term>
		/// </item>
		/// <item>
		/// <term/>
		/// <term>Pinned</term>
		/// <term>Pinned</term>
		/// <term>Pinned</term>
		/// <term>Pinned</term>
		/// <term>Excluded</term>
		/// </item>
		/// <item>
		/// <term/>
		/// <term>Unpinned</term>
		/// <term>Unpinned</term>
		/// <term>Unpinned</term>
		/// <term>Unpinned</term>
		/// <term>Excluded</term>
		/// </item>
		/// <item>
		/// <term/>
		/// <term>Excluded</term>
		/// <term>Unspecified</term>
		/// <term>Pinned</term>
		/// <term>Unspecified</term>
		/// <term>Excluded</term>
		/// </item>
		/// <item>
		/// <term>Directory</term>
		/// <term>Unspecified</term>
		/// <term>Unspecified</term>
		/// <term>Pinned</term>
		/// <term>Unpinned</term>
		/// <term>Excluded</term>
		/// </item>
		/// <item>
		/// <term/>
		/// <term>Pinned</term>
		/// <term>Pinned</term>
		/// <term>Pinned</term>
		/// <term>Pinned</term>
		/// <term>Excluded</term>
		/// </item>
		/// <item>
		/// <term/>
		/// <term>Unpinned</term>
		/// <term>Unpinned</term>
		/// <term>Unpinned</term>
		/// <term>Unpinned</term>
		/// <term>Excluded</term>
		/// </item>
		/// <item>
		/// <term/>
		/// <term>Excluded</term>
		/// <term>Unspecified</term>
		/// <term>Pinned</term>
		/// <term>Unpinned</term>
		/// <term>Excluded</term>
		/// </item>
		/// </list>
		/// </remarks>
		// https://docs.microsoft.com/en-us/windows/win32/api/cfapi/ne-cfapi-cf_pin_state typedef enum CF_PIN_STATE {
		// CF_PIN_STATE_UNSPECIFIED, CF_PIN_STATE_PINNED, CF_PIN_STATE_UNPINNED, CF_PIN_STATE_EXCLUDED, CF_PIN_STATE_INHERIT } ;
		[PInvokeData("cfapi.h", MSDNShortId = "F3074C9A-2805-47DE-9BA0-D7E02C4FF030")]
		public enum CF_PIN_STATE
		{
			/// <summary>The platform can decide freely when the placeholder’s content needs to present or absent locally on the disk.</summary>
			CF_PIN_STATE_UNSPECIFIED,

			/// <summary>
			/// The sync provider will be notified to fetch the placeholder’s content asynchronously after the pin request is received by
			/// the platform. There is no guarantee that the placeholders to be pinned will be fully available locally after a CfSetPinState
			/// call completes successfully. However, the platform will fail any dehydration request on pinned placeholders.
			/// </summary>
			CF_PIN_STATE_PINNED,

			/// <summary>
			/// The sync provider will be notified to dehydrate/invalidate the placeholder’s content on-disk asynchronously after the unpin
			/// request is received by the platform. There is no guarantee that the placeholders to be unpinned will be fully dehydrated
			/// after the API call completes successfully.
			/// </summary>
			CF_PIN_STATE_UNPINNED,

			/// <summary>
			/// the placeholder will never be synced to the cloud by the sync provider. This state can only be set by the sync provider.
			/// </summary>
			CF_PIN_STATE_EXCLUDED,

			/// <summary>
			/// The platform treats it as if the caller performs a move operation on the placeholder and hence re-evaluates the
			/// placeholder’s pin state based on its parent’s pin state. See the Remarks section for an inheritance table.
			/// </summary>
			CF_PIN_STATE_INHERIT,
		}

		/// <summary>Flags for creating a placeholder on a per-placeholder basis.</summary>
		// https://docs.microsoft.com/en-us/windows/win32/api/cfapi/ne-cfapi-cf_placeholder_create_flags typedef enum
		// CF_PLACEHOLDER_CREATE_FLAGS { CF_PLACEHOLDER_CREATE_FLAG_NONE, CF_PLACEHOLDER_CREATE_FLAG_DISABLE_ON_DEMAND_POPULATION,
		// CF_PLACEHOLDER_CREATE_FLAG_MARK_IN_SYNC, CF_PLACEHOLDER_CREATE_FLAG_SUPERSEDE } ;
		[PInvokeData("cfapi.h", MSDNShortId = "7DB55949-E209-490C-9FF9-53E1D72CD0FA")]
		[Flags]
		public enum CF_PLACEHOLDER_CREATE_FLAGS
		{
			/// <summary>No placeholder create flags.</summary>
			CF_PLACEHOLDER_CREATE_FLAG_NONE = 0,

			/// <summary>
			/// The newly created child placeholder directory is considered to have all of its children present locally. Applicable to a
			/// child placeholder directory only.
			/// </summary>
			CF_PLACEHOLDER_CREATE_FLAG_DISABLE_ON_DEMAND_POPULATION = 1,

			/// <summary>The newly created placeholder is marked as in-sync. Applicable to both placeholder files and directories.</summary>
			CF_PLACEHOLDER_CREATE_FLAG_MARK_IN_SYNC = 2,

			/// <summary/>
			CF_PLACEHOLDER_CREATE_FLAG_SUPERSEDE = 4,
		}

		/// <summary>Information classes for placeholder info.</summary>
		// https://docs.microsoft.com/en-us/windows/win32/api/cfapi/ne-cfapi-cf_placeholder_info_class typedef enum
		// CF_PLACEHOLDER_INFO_CLASS { CF_PLACEHOLDER_INFO_BASIC, CF_PLACEHOLDER_INFO_STANDARD } ;
		[PInvokeData("cfapi.h", MSDNShortId = "DA05148F-3EF0-4CC3-9233-883859FA00F1")]
		public enum CF_PLACEHOLDER_INFO_CLASS
		{
			/// <summary>Basic placeholder information. See CF_PLACEHOLDER_BASIC_INFO.</summary>
			[CorrespondingType(typeof(CF_PLACEHOLDER_BASIC_INFO), CorrespondingAction.Get)]
			CF_PLACEHOLDER_INFO_BASIC,

			/// <summary>Standard placeholder information. See CF_PLACEHOLDER_STANDARD_INFO.</summary>
			[CorrespondingType(typeof(CF_PLACEHOLDER_STANDARD_INFO), CorrespondingAction.Get)]
			CF_PLACEHOLDER_INFO_STANDARD,
		}

		/// <summary>Types of the range of placeholder file data.</summary>
		// https://docs.microsoft.com/en-us/windows/win32/api/cfapi/ne-cfapi-cf_placeholder_range_info_class typedef enum
		// CF_PLACEHOLDER_RANGE_INFO_CLASS { CF_PLACEHOLDER_RANGE_INFO_ONDISK, CF_PLACEHOLDER_RANGE_INFO_VALIDATED,
		// CF_PLACEHOLDER_RANGE_INFO_MODIFIED } ;
		[PInvokeData("cfapi.h", MSDNShortId = "04533C98-894C-422F-9BE5-F2746BF13567")]
		public enum CF_PLACEHOLDER_RANGE_INFO_CLASS
		{
			/// <summary>On-disk data is data that is physical present in the file, which is a super set of other types of ranges.</summary>
			CF_PLACEHOLDER_RANGE_INFO_ONDISK = 1,

			/// <summary>Validated data is a subset of the on-disk data that is currently in sync with the cloud.</summary>
			CF_PLACEHOLDER_RANGE_INFO_VALIDATED,

			/// <summary>
			/// Modified data is a subset of the on-disk data that is currently not in sync with the cloud, i.e., either modified or appended.
			/// </summary>
			CF_PLACEHOLDER_RANGE_INFO_MODIFIED,
		}

		/// <summary>The state of a placeholder file or folder.</summary>
		/// <remarks>
		/// Placeholder state information can be obtained by calling: CfGetPlaceholderStateFromAttributeTag,
		/// CfGetPlaceholderStateFromFileInfo, or CfGetPlaceholderStateFromFindData.
		/// </remarks>
		// https://docs.microsoft.com/en-us/windows/win32/api/cfapi/ne-cfapi-cf_placeholder_state typedef enum CF_PLACEHOLDER_STATE {
		// CF_PLACEHOLDER_STATE_NO_STATES, CF_PLACEHOLDER_STATE_PLACEHOLDER, CF_PLACEHOLDER_STATE_SYNC_ROOT,
		// CF_PLACEHOLDER_STATE_ESSENTIAL_PROP_PRESENT, CF_PLACEHOLDER_STATE_IN_SYNC, CF_PLACEHOLDER_STATE_PARTIAL,
		// CF_PLACEHOLDER_STATE_PARTIALLY_ON_DISK, CF_PLACEHOLDER_STATE_INVALID } ;
		[PInvokeData("cfapi.h", MSDNShortId = "5E814458-2045-4CFD-90AC-F1F53DEB4FD0")]
		[Flags]
		public enum CF_PLACEHOLDER_STATE : uint
		{
			/// <summary>When returned, the file or directory whose FileAttributes and ReparseTag examined by the API is not a placeholder.</summary>
			CF_PLACEHOLDER_STATE_NO_STATES = 0x00000000,

			/// <summary>The file or directory whose FileAttributes and ReparseTag examined by the API is a placeholder.</summary>
			CF_PLACEHOLDER_STATE_PLACEHOLDER = 0x00000001,

			/// <summary>The directory is both a placeholder directory as well as the sync root.</summary>
			CF_PLACEHOLDER_STATE_SYNC_ROOT = 0x00000002,

			/// <summary>
			/// The file or directory must be a placeholder and there exists an essential property in the property store of the file or directory.
			/// </summary>
			CF_PLACEHOLDER_STATE_ESSENTIAL_PROP_PRESENT = 0x00000004,

			/// <summary>The file or directory must be a placeholder and its content in sync with the cloud.</summary>
			CF_PLACEHOLDER_STATE_IN_SYNC = 0x00000008,

			/// <summary>
			/// The file or directory must be a placeholder and its content is not ready to be consumed by the user application, though it
			/// may or may not be fully present locally. An example is a placeholder file whose content has been fully downloaded to the
			/// local disk, but is yet to be validated by a sync provider that has registered the sync root with the hydration modifier VERIFICATION_REQUIRED.
			/// </summary>
			CF_PLACEHOLDER_STATE_PARTIAL = 0x00000010,

			/// <summary>
			/// The file or directory must be a placeholder and its content is not fully present locally. When this is set,
			/// CF_PLACEHOLDER_STATE_PARTIAL must also be set.
			/// </summary>
			CF_PLACEHOLDER_STATE_PARTIALLY_ON_DISK = 0x00000020,

			/// <summary>This is an invalid state when the API fails to parse the information of the file or directory.</summary>
			CF_PLACEHOLDER_STATE_INVALID = 0xffffffff,
		}

		/// <summary>Defines the population policy modifiers. This is a modifier that can be used with the primary policy: CF_POPULATION_POLICY_PRIMARY.</summary>
		// https://docs.microsoft.com/en-us/windows/win32/api/cfapi/ne-cfapi-cf_population_policy_modifier typedef enum
		// CF_POPULATION_POLICY_MODIFIER { CF_POPULATION_POLICY_MODIFIER_NONE } ;
		[PInvokeData("cfapi.h", MSDNShortId = "E8F8066C-BAAE-4576-BA8F-49074F7C3C8F")]
		[Flags]
		public enum CF_POPULATION_POLICY_MODIFIER : ushort
		{
			/// <summary>No policy modifier.</summary>
			CF_POPULATION_POLICY_MODIFIER_NONE = 0,
		}

		/// <summary>
		/// Allows a sync provider to control how placeholder directories and files should be created by the platform. This is the primary policy.
		/// </summary>
		// https://docs.microsoft.com/en-us/windows/win32/api/cfapi/ne-cfapi-cf_population_policy_primary typedef enum
		// CF_POPULATION_POLICY_PRIMARY { CF_POPULATION_POLICY_PARTIAL, CF_POPULATION_POLICY_FULL, CF_POPULATION_POLICY_ALWAYS_FULL } ;
		[PInvokeData("cfapi.h", MSDNShortId = "3EDCDE3D-AD47-4C4B-9F83-C89879D668DA")]
		public enum CF_POPULATION_POLICY_PRIMARY : ushort
		{
			/// <summary>
			/// With CF_POPULATION_POLICY_PARTIAL population policy, when the platform detects access on a not fully populated directory, it
			/// will request only the entries required by the user application from the sync provider. This policy is not currently
			/// supported by the platform.
			/// </summary>
			CF_POPULATION_POLICY_PARTIAL = 0,

			/// <summary>
			/// With CF_POPULATION_POLICY_FULL population policy, when the platform detects access on a not fully populated directory, it
			/// will request the sync provider return all entries under the directory before completing the user request.
			/// </summary>
			CF_POPULATION_POLICY_FULL = 2,

			/// <summary>
			/// When CF_POPULATION_POLICY_ALWAYS_FULL is selected, the platform assumes that the full name space is always available
			/// locally. It will never forward any directory enumeration request to the sync provider.
			/// </summary>
			CF_POPULATION_POLICY_ALWAYS_FULL = 3,
		}

		/// <summary>Flags for registering and updating a sync root.</summary>
		// https://docs.microsoft.com/en-us/windows/win32/api/cfapi/ne-cfapi-cf_register_flags typedef enum CF_REGISTER_FLAGS {
		// CF_REGISTER_FLAG_NONE, CF_REGISTER_FLAG_UPDATE, CF_REGISTER_FLAG_DISABLE_ON_DEMAND_POPULATION_ON_ROOT,
		// CF_REGISTER_FLAG_MARK_IN_SYNC_ON_ROOT } ;
		[PInvokeData("cfapi.h", MSDNShortId = "043670D7-5908-40B5-82A8-EFF05FCB391B")]
		[Flags]
		public enum CF_REGISTER_FLAGS
		{
			/// <summary>No registration flags.</summary>
			CF_REGISTER_FLAG_NONE = 0,

			/// <summary>Use this flag for modifying previously registered sync root identities and policies.</summary>
			CF_REGISTER_FLAG_UPDATE = 1,

			/// <summary>
			/// The on-demand directory/folder population behavior is globally controlled by the population policy. This flag allows a sync
			/// provider to opt out of the on-demand population behavior just for the sync root itself while keeping on-demand population on
			/// for all other directories under the sync root. This is useful when the sync provider would like to pre-populate the
			/// immediate child files/directories of the sync root.
			/// </summary>
			CF_REGISTER_FLAG_DISABLE_ON_DEMAND_POPULATION_ON_ROOT = 2,

			/// <summary>
			/// This flag allows a sync provider to mark the sync root to be registered in-sync simultaneously at the registration time. An
			/// alternative is to call CfSetInSyncState on the sync root later.
			/// </summary>
			CF_REGISTER_FLAG_MARK_IN_SYNC_ON_ROOT = 4,
		}

		/// <summary>Flags for reverting a placeholder file to a regular file.</summary>
		// https://docs.microsoft.com/en-us/windows/win32/api/cfapi/ne-cfapi-cf_revert_flags typedef enum CF_REVERT_FLAGS {
		// CF_REVERT_FLAG_NONE } ;
		[PInvokeData("cfapi.h", MSDNShortId = "71FDE7FA-99FC-4773-A857-8E1BF89ED7E4")]
		[Flags]
		public enum CF_REVERT_FLAGS
		{
			/// <summary>No placeholder revert flags.</summary>
			CF_REVERT_FLAG_NONE = 0,
		}

		/// <summary>The in-sync state flags for placeholder files and folders.</summary>
		// https://docs.microsoft.com/en-us/windows/win32/api/cfapi/ne-cfapi-cf_set_in_sync_flags typedef enum CF_SET_IN_SYNC_FLAGS {
		// CF_SET_IN_SYNC_FLAG_NONE } ;
		[PInvokeData("cfapi.h", MSDNShortId = "55A20F07-0B3E-4C1D-9E59-288DAE08D134")]
		[Flags]
		public enum CF_SET_IN_SYNC_FLAGS
		{
			/// <summary>No in-sync flag.</summary>
			CF_SET_IN_SYNC_FLAG_NONE = 0,
		}

		/// <summary>The placeholder pin flags.</summary>
		// https://docs.microsoft.com/en-us/windows/win32/api/cfapi/ne-cfapi-cf_set_pin_flags typedef enum CF_SET_PIN_FLAGS {
		// CF_SET_PIN_FLAG_NONE, CF_SET_PIN_FLAG_RECURSE, CF_SET_PIN_FLAG_RECURSE_ONLY, CF_SET_PIN_FLAG_RECURSE_STOP_ON_ERROR } ;
		[PInvokeData("cfapi.h", MSDNShortId = "6766931E-B2D4-4166-9B6E-E6D8F57E57B3")]
		[Flags]
		public enum CF_SET_PIN_FLAGS
		{
			/// <summary>No pin flag.</summary>
			CF_SET_PIN_FLAG_NONE = 0,

			/// <summary>
			/// The platform applies the pin state to the placeholder FileHandle and every file recursively beneath it (relevant only if
			/// FileHandle is a handle to a directory).
			/// </summary>
			CF_SET_PIN_FLAG_RECURSE = 1,

			/// <summary>
			/// The platform applies the pin state to every file recursively beneath the placeholder FileHandle, but not to FileHandle itself.
			/// </summary>
			CF_SET_PIN_FLAG_RECURSE_ONLY = 2,

			/// <summary>
			/// The platform will stop the recursion when encountering the first error; otherwise the platform skips the error and continues
			/// the recursion.
			/// </summary>
			CF_SET_PIN_FLAG_RECURSE_STOP_ON_ERROR = 4,
		}

		/// <summary>Current status of a sync provider.</summary>
		// https://docs.microsoft.com/en-us/windows/win32/api/cfapi/ne-cfapi-cf_sync_provider_status typedef enum CF_SYNC_PROVIDER_STATUS {
		// CF_PROVIDER_STATUS_DISCONNECTED, CF_PROVIDER_STATUS_IDLE, CF_PROVIDER_STATUS_POPULATE_NAMESPACE,
		// CF_PROVIDER_STATUS_POPULATE_METADATA, CF_PROVIDER_STATUS_POPULATE_CONTENT, CF_PROVIDER_STATUS_SYNC_INCREMENTAL,
		// CF_PROVIDER_STATUS_SYNC_FULL, CF_PROVIDER_STATUS_CONNECTIVITY_LOST, CF_PROVIDER_STATUS_CLEAR_FLAGS,
		// CF_PROVIDER_STATUS_TERMINATED, CF_PROVIDER_STATUS_ERROR } ;
		[PInvokeData("cfapi.h", MSDNShortId = "575A9F66-66D4-4443-9BCB-0CBD60DA27A0")]
		[Flags]
		public enum CF_SYNC_PROVIDER_STATUS : uint
		{
			/// <summary>The sync provider is disconnected.</summary>
			CF_PROVIDER_STATUS_DISCONNECTED = 0x00000000,

			/// <summary>The sync provider is idle.</summary>
			CF_PROVIDER_STATUS_IDLE = 0x00000001,

			/// <summary>The sync provider is populating a namespace.</summary>
			CF_PROVIDER_STATUS_POPULATE_NAMESPACE = 0x00000002,

			/// <summary>The sync provider is populating placeholder metadata.</summary>
			CF_PROVIDER_STATUS_POPULATE_METADATA = 0x00000004,

			/// <summary>The sync provider is populating placeholder content.</summary>
			CF_PROVIDER_STATUS_POPULATE_CONTENT = 0x00000008,

			/// <summary>The sync provider is incrementally syncing placeholder content.</summary>
			CF_PROVIDER_STATUS_SYNC_INCREMENTAL = 0x00000010,

			/// <summary>The sync provider has fully synced placeholder file data.</summary>
			CF_PROVIDER_STATUS_SYNC_FULL = 0x00000020,

			/// <summary>The sync provider has lost connectivity.</summary>
			CF_PROVIDER_STATUS_CONNECTIVITY_LOST = 0x00000040,

			/// <summary>Clears the flags of the sync provider.</summary>
			CF_PROVIDER_STATUS_CLEAR_FLAGS = 0x80000000,

			/// <summary/>
			CF_PROVIDER_STATUS_TERMINATED = 0xC0000001,

			/// <summary/>
			CF_PROVIDER_STATUS_ERROR = 0xC0000002,
		}

		/// <summary>Types of sync root information.</summary>
		// https://docs.microsoft.com/en-us/windows/win32/api/cfapi/ne-cfapi-cf_sync_root_info_class typedef enum CF_SYNC_ROOT_INFO_CLASS {
		// CF_SYNC_ROOT_INFO_BASIC, CF_SYNC_ROOT_INFO_STANDARD, CF_SYNC_ROOT_INFO_PROVIDER } ;
		[PInvokeData("cfapi.h", MSDNShortId = "4415E075-048E-4B9F-B293-5F7A63CAE3A4")]
		public enum CF_SYNC_ROOT_INFO_CLASS
		{
			/// <summary>Basic sync root information. See CF_SYNC_ROOT_BASIC_INFO.</summary>
			[CorrespondingType(typeof(CF_SYNC_ROOT_BASIC_INFO), CorrespondingAction.Get)]
			CF_SYNC_ROOT_INFO_BASIC,

			/// <summary>Standard sync root information. See CF_SYNC_ROOT_STANDARD_INFO.</summary>
			[CorrespondingType(typeof(CF_SYNC_ROOT_STANDARD_INFO), CorrespondingAction.Get)]
			CF_SYNC_ROOT_INFO_STANDARD,

			/// <summary>Sync root provider information. See CF_SYNC_ROOT_PROVIDER_INFO.</summary>
			[CorrespondingType(typeof(CF_SYNC_ROOT_PROVIDER_INFO), CorrespondingAction.Get)]
			CF_SYNC_ROOT_INFO_PROVIDER,
		}

		/// <summary>Flags for updating a placeholder file or directory.</summary>
		// https://docs.microsoft.com/en-us/windows/win32/api/cfapi/ne-cfapi-cf_update_flags typedef enum CF_UPDATE_FLAGS {
		// CF_UPDATE_FLAG_NONE, CF_UPDATE_FLAG_VERIFY_IN_SYNC, CF_UPDATE_FLAG_MARK_IN_SYNC, CF_UPDATE_FLAG_DEHYDRATE,
		// CF_UPDATE_FLAG_ENABLE_ON_DEMAND_POPULATION, CF_UPDATE_FLAG_DISABLE_ON_DEMAND_POPULATION, CF_UPDATE_FLAG_REMOVE_FILE_IDENTITY,
		// CF_UPDATE_FLAG_CLEAR_IN_SYNC, CF_UPDATE_FLAG_REMOVE_PROPERTY, CF_UPDATE_FLAG_PASSTHROUGH_FS_METADATA } ;
		[PInvokeData("cfapi.h", MSDNShortId = "83EBEF22-9EAE-4B51-AA23-325FA96EB070")]
		[Flags]
		public enum CF_UPDATE_FLAGS : uint
		{
			/// <summary>No update flags.</summary>
			CF_UPDATE_FLAG_NONE = 0x00000000,

			/// <summary>
			/// The update will fail if the CF_UPDATE_FLAG_MARK_IN_SYNC attribute is not currently set on the placeholder. This is to
			/// prevent a race between syncing changes from the cloud down to a local placeholder and the placeholder’s data stream getting
			/// locally modified.
			/// </summary>
			CF_UPDATE_FLAG_VERIFY_IN_SYNC = 0x00000001,

			/// <summary>The platform marks the placeholder as in-sync upon a successful update placeholder operation.</summary>
			CF_UPDATE_FLAG_MARK_IN_SYNC = 0x00000002,

			/// <summary>
			/// Applicable to files only. When specified, the platform dehydrates the file after updating the placeholder successfully. The
			/// caller must acquire an exclusive handle when specifying this flag or data corruptions can occur. Note that the platform does
			/// not validate the exclusiveness of the handle.
			/// </summary>
			CF_UPDATE_FLAG_DEHYDRATE = 0x00000004,

			/// <summary>
			/// Applicable to directories only. When specified, it marks the updated placeholder directory partially populated such that any
			/// future access to it will result in a FETCH_PLACEHOLDERS callback sent to the sync provider.
			/// </summary>
			CF_UPDATE_FLAG_ENABLE_ON_DEMAND_POPULATION = 0x00000008,

			/// <summary>
			/// Applicable to directories only. When specified, it marks the updated placeholder directory fully populated such that any
			/// future access to it will be handled by the platform without any callbacks to the sync provider.
			/// </summary>
			CF_UPDATE_FLAG_DISABLE_ON_DEMAND_POPULATION = 0x00000010,

			/// <summary>
			/// When specified, FileIdentity and FileIdentityLength in CfUpdatePlaceholder are ignored and the platform will remove the
			/// existing file identity blob on the placeholder upon a successful update call.
			/// </summary>
			CF_UPDATE_FLAG_REMOVE_FILE_IDENTITY = 0x00000020,

			/// <summary>The platform marks the placeholder as not in-sync upon a successful update placeholder operation.</summary>
			CF_UPDATE_FLAG_CLEAR_IN_SYNC = 0x00000040,

			/// <summary>
			/// Note This value is new for Windows 10, version 1803.The platform removes all existing extrinsic properties on the placeholder.
			/// </summary>
			CF_UPDATE_FLAG_REMOVE_PROPERTY = 0x00000080,

			/// <summary>
			/// Note This value is new for Windows 10, version 1803.The platform passes CF_FS_METADATA to the file system without any
			/// filtering; otherwise, the platform skips setting any fields whose value is 0.
			/// </summary>
			CF_UPDATE_FLAG_PASSTHROUGH_FS_METADATA = 0x00000100,
		}

		/// <summary>Contains common callback information.</summary>
		/// <remarks>
		/// <para>A file name is considered normalized if all of the following are true:</para>
		/// <list type="bullet">
		/// <item>
		/// <term>
		/// It contains the full directory path for the file, including the volume name, unless the user opened the file by file ID but does
		/// not have traverse privilege for the entire path. (For more information, see FltGetFileNameInformation.)
		/// </term>
		/// </item>
		/// <item>
		/// <term>The volume name is the volume's non-persistent device object name (for example, "\Device\HarddiskVolume1").</term>
		/// </item>
		/// <item>
		/// <term>All short names are expanded to the equivalent long names.</term>
		/// </item>
		/// <item>
		/// <term>Any trailing ":$DATA" or "::$DATA" strings are removed from the stream name.</term>
		/// </item>
		/// <item>
		/// <term>All mount points are resolved.</term>
		/// </item>
		/// </list>
		/// </remarks>
		// https://docs.microsoft.com/en-us/windows/win32/api/cfapi/ns-cfapi-cf_callback_info typedef struct CF_CALLBACK_INFO { DWORD
		// StructSize; CF_CONNECTION_KEY ConnectionKey; LPVOID CallbackContext; PCWSTR VolumeGuidName; PCWSTR VolumeDosName; DWORD
		// VolumeSerialNumber; LARGE_INTEGER SyncRootFileId; LPCVOID SyncRootIdentity; DWORD SyncRootIdentityLength; LARGE_INTEGER FileId;
		// LARGE_INTEGER FileSize; LPCVOID FileIdentity; DWORD FileIdentityLength; PCWSTR NormalizedPath; CF_TRANSFER_KEY TransferKey; UCHAR
		// PriorityHint; PCORRELATION_VECTOR CorrelationVector; CF_PROCESS_INFO *ProcessInfo; CF_REQUEST_KEY RequestKey; } CF_CALLBACK_INFO;
		[PInvokeData("cfapi.h", MSDNShortId = "EF24E61E-4AF7-4946-A326-1F045267AE01")]
		[StructLayout(LayoutKind.Sequential)]
		public struct CF_CALLBACK_INFO
		{
			/// <summary>The size of the structure.</summary>
			public uint StructSize;

			/// <summary>An opaque handle created by CfConnectSyncRoot for a sync root managed by the sync provider.</summary>
			public CF_CONNECTION_KEY ConnectionKey;

			/// <summary>points to an opaque blob that the sync provider provides at the sync root connect time.</summary>
			public IntPtr CallbackContext;

			/// <summary>GUID name of the volume on which the placeholder file/directory to be serviced resides. It is in the form: “\?\Volume{GUID}”.</summary>
			[MarshalAs(UnmanagedType.LPWStr)] public string VolumeGuidName;

			/// <summary>DOS drive letter of the volume in the form of “X:” where X is the drive letter.</summary>
			[MarshalAs(UnmanagedType.LPWStr)] public string VolumeDosName;

			/// <summary>The serial number of the volume.</summary>
			public uint VolumeSerialNumber;

			/// <summary>
			/// A 64 bit file system maintained volume-wide unique ID of the sync root under which the placeholder file/directory to be
			/// serviced resides.
			/// </summary>
			public long SyncRootFileId;

			/// <summary>Points to the opaque blob provided by the sync provider at the sync root registration time.</summary>
			public IntPtr SyncRootIdentity;

			/// <summary>The length, in bytes, of the <c>SyncRootIdentity</c>.</summary>
			public uint SyncRootIdentityLength;

			/// <summary>A 64 bit file system maintained, volume-wide unique ID of the placeholder file/directory to be serviced.</summary>
			public long FileId;

			/// <summary>
			/// The logical size of the placeholder file to be serviced. It is always 0 if the subject of the callback is a directory.
			/// </summary>
			public long FileSize;

			/// <summary>Points to the opaque blob that the sync provider provides at the placeholder creation/conversion/update time.</summary>
			public IntPtr FileIdentity;

			/// <summary>The length, in bytes, of <c>FileIdentity</c>.</summary>
			public uint FileIdentityLength;

			/// <summary>
			/// The absolute path of the placeholder file/directory to be serviced on the volume identified by VolumeGuidName/VolumeDosName.
			/// It starts from the root directory of the volume. See the Remarks section for more details.
			/// </summary>
			[MarshalAs(UnmanagedType.LPWStr)] public string NormalizedPath;

			/// <summary>
			/// An opaque handle to the placeholder file/directory to be serviced. The sync provider must pass it back to the CfExecute call
			/// in order to perform the desired operation on the file/directory.
			/// </summary>
			public CF_TRANSFER_KEY TransferKey;

			/// <summary>
			/// A numeric scale given to the sync provider to describe the relative priority of one fetch compared to another fetch, in
			/// order to provide the most responsive experience to the user. The values range from 0 (lowest possible priority) to 15
			/// (highest possible priority).
			/// </summary>
			public byte PriorityHint;

			/// <summary>An optional correlation vector.</summary>
			public IntPtr CorrelationVector;

			/// <summary>Points to a structure that contains the information about the user process that triggers this callback.</summary>
			public IntPtr ProcessInfo;

			/// <summary/>
			public CF_REQUEST_KEY RequestKey;
		}

		/// <summary>Contains callback specific parameters such as file offset, length, flags, etc.</summary>
		// https://docs.microsoft.com/en-us/windows/win32/api/cfapi/ns-cfapi-cf_callback_parameters typedef struct CF_CALLBACK_PARAMETERS {
		// ULONG ParamSize; union { struct { CF_CALLBACK_CANCEL_FLAGS Flags; union { struct { LARGE_INTEGER FileOffset; LARGE_INTEGER
		// Length; } FetchData; } DUMMYUNIONNAME; } Cancel; struct { CF_CALLBACK_FETCH_DATA_FLAGS Flags; LARGE_INTEGER RequiredFileOffset;
		// LARGE_INTEGER RequiredLength; LARGE_INTEGER OptionalFileOffset; LARGE_INTEGER OptionalLength; LARGE_INTEGER LastDehydrationTime;
		// CF_CALLBACK_DEHYDRATION_REASON LastDehydrationReason; } FetchData; struct { CF_CALLBACK_VALIDATE_DATA_FLAGS Flags; LARGE_INTEGER
		// RequiredFileOffset; LARGE_INTEGER RequiredLength; } ValidateData; struct { CF_CALLBACK_FETCH_PLACEHOLDERS_FLAGS Flags; PCWSTR
		// Pattern; } FetchPlaceholders; struct { CF_CALLBACK_OPEN_COMPLETION_FLAGS Flags; } OpenCompletion; struct {
		// CF_CALLBACK_CLOSE_COMPLETION_FLAGS Flags; } CloseCompletion; struct { CF_CALLBACK_DEHYDRATE_FLAGS Flags;
		// CF_CALLBACK_DEHYDRATION_REASON Reason; } Dehydrate; struct { CF_CALLBACK_DEHYDRATE_COMPLETION_FLAGS Flags;
		// CF_CALLBACK_DEHYDRATION_REASON Reason; } DehydrateCompletion; struct { CF_CALLBACK_DELETE_FLAGS Flags; } Delete; struct {
		// CF_CALLBACK_DELETE_COMPLETION_FLAGS Flags; } DeleteCompletion; struct { CF_CALLBACK_RENAME_FLAGS Flags; PCWSTR TargetPath; }
		// Rename; struct { CF_CALLBACK_RENAME_COMPLETION_FLAGS Flags; PCWSTR SourcePath; } RenameCompletion; } DUMMYUNIONNAME; } CF_CALLBACK_PARAMETERS;
		[PInvokeData("cfapi.h", MSDNShortId = "FA403E9E-5EFA-4285-9619-614DB0044FFB")]
		[StructLayout(LayoutKind.Sequential)]
		public struct CF_CALLBACK_PARAMETERS
		{
			/// <summary/>
			public uint ParamSize;

			private uint pad;

			/// <summary/>
			[MarshalAs(UnmanagedType.ByValArray, SizeConst = 56)]
			public byte[] Content;

			/// <summary/>
			public CANCEL Cancel => GetParam<CANCEL>();

			/// <summary/>
			public FETCHDATA FetchData => GetParam<FETCHDATA>();

			/// <summary/>
			public VALIDATEDATA ValidateData => GetParam<VALIDATEDATA>();

			/// <summary/>
			public FETCHPLACEHOLDERS FetchPlaceholders => GetParam<FETCHPLACEHOLDERS>();

			/// <summary/>
			public OPENCOMPLETION OpenCompletion => GetParam<OPENCOMPLETION>();

			/// <summary/>
			public CLOSECOMPLETION CloseCompletion => GetParam<CLOSECOMPLETION>();

			/// <summary/>
			public DEHYDRATE Dehydrate => GetParam<DEHYDRATE>();

			/// <summary/>
			public DEHYDRATECOMPLETION DehydrateCompletion => GetParam<DEHYDRATECOMPLETION>();

			/// <summary/>
			public DELETE Delete => GetParam<DELETE>();

			/// <summary/>
			public DELETECOMPLETION DeleteCompletion => GetParam<DELETECOMPLETION>();

			/// <summary/>
			public RENAME Rename => GetParam<RENAME>();

			/// <summary/>
			public RENAMECOMPLETION RenameCompletion => GetParam<RENAMECOMPLETION>();

			/// <summary>Gets the parameter value for this structure.</summary>
			/// <typeparam name="T">The type of the structure to retrieve.</typeparam>
			/// <returns>The requested structure.</returns>
			public T GetParam<T>() where T : struct
			{
				using var ptr = new SafeHGlobalHandle(Content);
				return ptr.ToStructure<T>();
			}

			/// <summary>Contains callback specific parameters such as file offset, length, flags, etc.</summary>
			[PInvokeData("cfapi.h", MSDNShortId = "FA403E9E-5EFA-4285-9619-614DB0044FFB")]
			[StructLayout(LayoutKind.Sequential, Pack = 8)]
			public struct CANCEL
			{
				/// <summary>Cancel data flags.</summary>
				public CF_CALLBACK_CANCEL_FLAGS Flags;

				/// <summary/>
				public CANCELFETCHDATA FetchData;

				/// <summary/>
				[StructLayout(LayoutKind.Sequential)]
				public struct CANCELFETCHDATA
				{
					/// <summary>Offset, in bytes, for specifying the range of data.</summary>
					public long FileOffset;

					/// <summary>Length of the data in bytes.</summary>
					public long Length;
				}
			}

			/// <summary>Contains callback specific parameters such as file offset, length, flags, etc.</summary>
			[PInvokeData("cfapi.h", MSDNShortId = "FA403E9E-5EFA-4285-9619-614DB0044FFB")]
			[StructLayout(LayoutKind.Sequential)]
			public struct CLOSECOMPLETION
			{
				/// <summary>Placeholder close completion flags.</summary>
				public CF_CALLBACK_CLOSE_COMPLETION_FLAGS Flags;
			}

			/// <summary>Contains callback specific parameters such as file offset, length, flags, etc.</summary>
			[PInvokeData("cfapi.h", MSDNShortId = "FA403E9E-5EFA-4285-9619-614DB0044FFB")]
			[StructLayout(LayoutKind.Sequential)]
			public struct DEHYDRATE
			{
				/// <summary>Placeholder dehydration flags.</summary>
				public CF_CALLBACK_DEHYDRATE_FLAGS Flags;

				/// <summary/>
				public CF_CALLBACK_DEHYDRATION_REASON Reason;
			}

			/// <summary>Contains callback specific parameters such as file offset, length, flags, etc.</summary>
			[PInvokeData("cfapi.h", MSDNShortId = "FA403E9E-5EFA-4285-9619-614DB0044FFB")]
			[StructLayout(LayoutKind.Sequential)]
			public struct DEHYDRATECOMPLETION
			{
				/// <summary/>
				public CF_CALLBACK_DEHYDRATE_COMPLETION_FLAGS Flags;

				/// <summary/>
				public CF_CALLBACK_DEHYDRATION_REASON Reason;
			}

			/// <summary>Contains callback specific parameters such as file offset, length, flags, etc.</summary>
			[PInvokeData("cfapi.h", MSDNShortId = "FA403E9E-5EFA-4285-9619-614DB0044FFB")]
			[StructLayout(LayoutKind.Sequential)]
			public struct DELETE
			{
				/// <summary>Placeholder deletion flags.</summary>
				public CF_CALLBACK_DELETE_FLAGS Flags;
			}

			/// <summary>Contains callback specific parameters such as file offset, length, flags, etc.</summary>
			[PInvokeData("cfapi.h", MSDNShortId = "FA403E9E-5EFA-4285-9619-614DB0044FFB")]
			[StructLayout(LayoutKind.Sequential)]
			public struct DELETECOMPLETION
			{
				/// <summary>Placeholder deletion complete flags.</summary>
				public CF_CALLBACK_DELETE_COMPLETION_FLAGS Flags;
			}

			/// <summary>Contains callback specific parameters such as file offset, length, flags, etc.</summary>
			[PInvokeData("cfapi.h", MSDNShortId = "FA403E9E-5EFA-4285-9619-614DB0044FFB")]
			[StructLayout(LayoutKind.Sequential)]
			public struct FETCHDATA
			{
				/// <summary>Fetch data flags.</summary>
				public CF_CALLBACK_FETCH_DATA_FLAGS Flags;

				/// <summary>Offset, in bytes, for specifying the required range of data.</summary>
				public long RequiredFileOffset;

				/// <summary>Length of the required data to retrieve, in bytes.</summary>
				public long RequiredLength;

				/// <summary>
				/// Offset, in bytes, of a broader piece of data to provide to a sync provider. This is optional and can be used if the sync
				/// provider prefers to work with larger segments of data.
				/// </summary>
				public long OptionalFileOffset;

				/// <summary>
				/// Length, in bytes, of a broader piece of data to provide to a sync provider. This is optional and can be used if the sync
				/// provider prefers to work with larger segments of data.
				/// </summary>
				public long OptionalLength;

				/// <summary/>
				public long LastDehydrationTime;

				/// <summary/>
				public CF_CALLBACK_DEHYDRATION_REASON LastDehydrationReason;
			}

			/// <summary>Contains callback specific parameters such as file offset, length, flags, etc.</summary>
			[PInvokeData("cfapi.h", MSDNShortId = "FA403E9E-5EFA-4285-9619-614DB0044FFB")]
			[StructLayout(LayoutKind.Sequential)]
			public struct FETCHPLACEHOLDERS
			{
				/// <summary>Flags for fetching placeholder metadata.</summary>
				public CF_CALLBACK_FETCH_PLACEHOLDERS_FLAGS Flags;

				/// <summary>
				/// A standard Windows file pattern which may contain wildcard characters (‘?’, ‘*’). All placeholders information matching the
				/// pattern must be transferred, but not necessarily in one-shot, as a minimum requirement. Alternatively, a sync provider may
				/// choose to not transfer placeholders matching the pattern.
				/// </summary>
				[MarshalAs(UnmanagedType.LPWStr)]
				public string Pattern;
			}

			/// <summary>Contains callback specific parameters such as file offset, length, flags, etc.</summary>
			[PInvokeData("cfapi.h", MSDNShortId = "FA403E9E-5EFA-4285-9619-614DB0044FFB")]
			[StructLayout(LayoutKind.Sequential)]
			public struct OPENCOMPLETION
			{
				/// <summary>Placeholder open completion flags.</summary>
				public CF_CALLBACK_OPEN_COMPLETION_FLAGS Flags;
			}

			/// <summary>Contains callback specific parameters such as file offset, length, flags, etc.</summary>
			[PInvokeData("cfapi.h", MSDNShortId = "FA403E9E-5EFA-4285-9619-614DB0044FFB")]
			[StructLayout(LayoutKind.Sequential)]
			public struct RENAME
			{
				/// <summary>Rename placeholder flags.</summary>
				public CF_CALLBACK_RENAME_FLAGS Flags;

				/// <summary>The full rename/move target path relative to the volume.</summary>
				[MarshalAs(UnmanagedType.LPWStr)]
				public string TargetPath;
			}

			/// <summary>Contains callback specific parameters such as file offset, length, flags, etc.</summary>
			[PInvokeData("cfapi.h", MSDNShortId = "FA403E9E-5EFA-4285-9619-614DB0044FFB")]
			[StructLayout(LayoutKind.Sequential)]
			public struct RENAMECOMPLETION
			{
				/// <summary>Rename completion placeholder flags.</summary>
				public CF_CALLBACK_RENAME_COMPLETION_FLAGS Flags;

				/// <summary>The full source link path relative to the volume.</summary>
				[MarshalAs(UnmanagedType.LPWStr)]
				public string SourcePath;
			}

			/// <summary>Contains callback specific parameters such as file offset, length, flags, etc.</summary>
			[PInvokeData("cfapi.h", MSDNShortId = "FA403E9E-5EFA-4285-9619-614DB0044FFB")]
			[StructLayout(LayoutKind.Sequential)]
			public struct VALIDATEDATA
			{
				/// <summary>Data validation flags.</summary>
				public CF_CALLBACK_VALIDATE_DATA_FLAGS Flags;

				/// <summary>Offset, in bytes, for specifying the range of data to validate.</summary>
				public long RequiredFileOffset;

				/// <summary>Length, in bytes, of the data to validate.</summary>
				public long RequiredLength;
			}
		}

		/// <summary>The callbacks to be registered by the sync provider.</summary>
		/// <remarks>
		/// <para>
		/// This callback registration is how a sync provider communicates to the library which functions to call to execute various
		/// requests from the platform.
		/// </para>
		/// <para>
		/// Note that the sync provider only needs to register implemented callbacks, and <c>CF_CALLBACK_REGISTRATION</c> should always end
		/// with <c>CF_CALLBACK_REGISTRATION_END</c>.
		/// </para>
		/// </remarks>
		// https://docs.microsoft.com/en-us/windows/win32/api/cfapi/ns-cfapi-cf_callback_registration typedef struct
		// CF_CALLBACK_REGISTRATION { CF_CALLBACK_TYPE Type; CF_CALLBACK Callback; } CF_CALLBACK_REGISTRATION;
		[PInvokeData("cfapi.h", MSDNShortId = "F1633983-DAB2-4072-AA9E-DC7015E6B988")]
		[StructLayout(LayoutKind.Sequential)]
		public struct CF_CALLBACK_REGISTRATION
		{
			/// <summary>The type of callback to be registered.</summary>
			public CF_CALLBACK_TYPE Type;

			/// <summary>A pointer to the callback function.</summary>
			[MarshalAs(UnmanagedType.FunctionPtr)]
			public CF_CALLBACK Callback;

			/// <summary>An instance of <c>CF_CALLBACK_REGISTRATION</c> that indicates the end of the registration list.</summary>
			public static readonly CF_CALLBACK_REGISTRATION CF_CALLBACK_REGISTRATION_END = new CF_CALLBACK_REGISTRATION { Type = CF_CALLBACK_TYPE.CF_CALLBACK_TYPE_NONE };
		}

		/// <summary>Opaque handle to a connection key.</summary>
		[PInvokeData("cfapi.h")]
		[StructLayout(LayoutKind.Sequential)]
		public struct CF_CONNECTION_KEY
		{
			private long Internal;
		}

		/// <summary>Specifies a range of data in a placeholder file.</summary>
		// https://docs.microsoft.com/en-us/windows/win32/api/cfapi/ns-cfapi-cf_file_range typedef struct CF_FILE_RANGE { LARGE_INTEGER
		// StartingOffset; LARGE_INTEGER Length; } CF_FILE_RANGE;
		[PInvokeData("cfapi.h", MSDNShortId = "DAE43446-725E-490B-AE1B-EA6CB31F4358")]
		[StructLayout(LayoutKind.Sequential)]
		public struct CF_FILE_RANGE
		{
			/// <summary>The offset of the starting point of the data.</summary>
			public long StartingOffset;

			/// <summary>The length of the data, in bytes.</summary>
			public long Length;
		}

		/// <summary>A structure to describe the location and range of data in a file.</summary>
		// https://docs.microsoft.com/en-us/previous-versions/windows/desktop/legacy/mt844616(v=vs.85) typedef struct __CF_FILE_RANGE_BUFFER
		// { LARGE_INTEGER FileOffset; LARGE_INTEGER Length; } CF_FILE_RANGE_BUFFER;
		[PInvokeData("CfApi.h")]
		[StructLayout(LayoutKind.Sequential)]
		public struct CF_FILE_RANGE_BUFFER
		{
			/// <summary>The offset of the range of data within a file.</summary>
			public long FileOffset;

			/// <summary>The length, in bytes of the data range.</summary>
			public long Length;
		}

		/// <summary>Placeholder file or directory metadata.</summary>
		// https://docs.microsoft.com/en-us/windows/win32/api/cfapi/ns-cfapi-cf_fs_metadata typedef struct CF_FS_METADATA { FILE_BASIC_INFO
		// BasicInfo; LARGE_INTEGER FileSize; } CF_FS_METADATA;
		[PInvokeData("cfapi.h", MSDNShortId = "A6D4473A-C93A-4B56-9EB0-9B44A56E5D28")]
		[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Ansi)]
		public struct CF_FS_METADATA
		{
			/// <summary>Basic file information.</summary>
			public FILE_BASIC_INFO BasicInfo;

			/// <summary>The size of the file, in bytes.</summary>
			public long FileSize;
		}

		/// <summary>Specifies the primary hydration policy and its modifier.</summary>
		// https://docs.microsoft.com/en-us/windows/win32/api/cfapi/ns-cfapi-cf_hydration_policy typedef struct CF_HYDRATION_POLICY {
		// CF_HYDRATION_POLICY_PRIMARY_USHORT Primary; CF_HYDRATION_POLICY_MODIFIER_USHORT Modifier; } CF_HYDRATION_POLICY;
		[PInvokeData("cfapi.h", MSDNShortId = "1541E108-7AE4-4899-8940-94FD264C1B10")]
		[StructLayout(LayoutKind.Sequential)]
		public struct CF_HYDRATION_POLICY
		{
			/// <summary>The primary hydration policy.</summary>
			public CF_HYDRATION_POLICY_PRIMARY Primary;

			/// <summary>The hydration policy modifier.</summary>
			public CF_HYDRATION_POLICY_MODIFIER Modifier;
		}

		/// <summary>Information about an operation on a placeholder file or folder.</summary>
		/// <remarks>
		/// The platform provides the <c>ConnectionKey</c>, <c>TransferKey</c>, and <c>CorrelationVector</c> to all callback functions
		/// registered via CfConnectSyncRoot. Additionally, sync providers can obtain a <c>TransferKey</c> using CfGetTransferKey and a
		/// <c>CorrelationVector</c> using CfGetCorrelationVector.
		/// </remarks>
		// https://docs.microsoft.com/en-us/windows/win32/api/cfapi/ns-cfapi-cf_operation_info typedef struct CF_OPERATION_INFO { ULONG
		// StructSize; CF_OPERATION_TYPE Type; CF_CONNECTION_KEY ConnectionKey; CF_TRANSFER_KEY TransferKey; const CORRELATION_VECTOR
		// *CorrelationVector; const CF_SYNC_STATUS *SyncStatus; CF_REQUEST_KEY RequestKey; } CF_OPERATION_INFO;
		[PInvokeData("cfapi.h", MSDNShortId = "4AE9A968-1325-4EFF-8F5B-8F465740B0C4")]
		[StructLayout(LayoutKind.Sequential)]
		public struct CF_OPERATION_INFO
		{
			/// <summary>The size of the structure.</summary>
			public uint StructSize;

			/// <summary>The type of operation performed.</summary>
			public CF_OPERATION_TYPE Type;

			/// <summary>A connection key obtained for the communication channel.</summary>
			public CF_CONNECTION_KEY ConnectionKey;

			/// <summary>An opaque handle to the placeholder.</summary>
			public CF_TRANSFER_KEY TransferKey;

			/// <summary>A correlation vector on a placeholder used for telemetry purposes.</summary>
			public IntPtr CorrelationVector;

			/// <summary>
			/// <para><c>Note</c> This member is new for Windows 10, version 1803.</para>
			/// <para>The current sync status of the platform.</para>
			/// <para>
			/// The platform queries this information upon any failed operations on a cloud file placeholder. If a structure is available,
			/// the platform will use the information provided to construct a more meaningful and actionable message to the user. The
			/// platform will keep this information on the file until the last handle on it goes away. If <c>null</c>, the platform will
			/// clear the previously set sync status, if there is one.
			/// </para>
			/// </summary>
			public IntPtr SyncStatus;

			/// <summary/>
			public CF_REQUEST_KEY RequestKey;
		}

		/// <summary>Parameters of an operation on a placeholder file or folder.</summary>
		// https://docs.microsoft.com/en-us/windows/win32/api/cfapi/ns-cfapi-cf_operation_parameters typedef struct CF_OPERATION_PARAMETERS
		// { ULONG ParamSize; union { struct { CF_OPERATION_TRANSFER_DATA_FLAGS Flags; NTSTATUS CompletionStatus; LPCVOID Buffer;
		// LARGE_INTEGER Offset; LARGE_INTEGER Length; } TransferData; struct { CF_OPERATION_RETRIEVE_DATA_FLAGS Flags; LPVOID Buffer;
		// LARGE_INTEGER Offset; LARGE_INTEGER Length; LARGE_INTEGER ReturnedLength; } RetrieveData; struct { CF_OPERATION_ACK_DATA_FLAGS
		// Flags; NTSTATUS CompletionStatus; LARGE_INTEGER Offset; LARGE_INTEGER Length; } AckData; struct {
		// CF_OPERATION_RESTART_HYDRATION_FLAGS Flags; const CF_FS_METADATA *FsMetadata; LPCVOID FileIdentity; DWORD FileIdentityLength; }
		// RestartHydration; struct { CF_OPERATION_TRANSFER_PLACEHOLDERS_FLAGS Flags; NTSTATUS CompletionStatus; LARGE_INTEGER
		// PlaceholderTotalCount; CF_PLACEHOLDER_CREATE_INFO *PlaceholderArray; DWORD PlaceholderCount; DWORD EntriesProcessed; }
		// TransferPlaceholders; struct { CF_OPERATION_ACK_DEHYDRATE_FLAGS Flags; NTSTATUS CompletionStatus; LPCVOID FileIdentity; DWORD
		// FileIdentityLength; } AckDehydrate; struct { CF_OPERATION_ACK_RENAME_FLAGS Flags; NTSTATUS CompletionStatus; } AckRename; struct
		// { CF_OPERATION_ACK_DELETE_FLAGS Flags; NTSTATUS CompletionStatus; } AckDelete; } DUMMYUNIONNAME; } CF_OPERATION_PARAMETERS;
		[PInvokeData("cfapi.h", MSDNShortId = "668C682E-47C2-41BC-A4F9-AA2F2B516F54")]
		[StructLayout(LayoutKind.Sequential)]
		public struct CF_OPERATION_PARAMETERS
		{
			/// <summary/>
			public uint ParamSize;

			// Yes, this is strange, but needed to deal with struct size changing based on pointer size (40/48).
			private uint pad4_8;
			private ulong pad8_16;
			private ulong pad16_24;
			private ulong pad24_32;
			private IntPtr padp1;
			private IntPtr padp2;

			/// <summary/>
			public TRANSFERDATA TransferData { get => GetParam<TRANSFERDATA>(); set => SetParam(value); }

			/// <summary/>
			public RETRIEVEDATA RetrieveData { get => GetParam<RETRIEVEDATA>(); set => SetParam(value); }

			/// <summary/>
			public ACKDATA AckData { get => GetParam<ACKDATA>(); set => SetParam(value); }

			/// <summary/>
			public RESTARTHYDRATION RestartHydration { get => GetParam<RESTARTHYDRATION>(); set => SetParam(value); }

			/// <summary/>
			public TRANSFERPLACEHOLDERS TransferPlaceholders { get => GetParam<TRANSFERPLACEHOLDERS>(); set => SetParam(value); }

			/// <summary/>
			public ACKDEHYDRATE AckDehydrate { get => GetParam<ACKDEHYDRATE>(); set => SetParam(value); }

			/// <summary/>
			public ACKRENAME AckRename { get => GetParam<ACKRENAME>(); set => SetParam(value); }

			/// <summary/>
			public ACKDELETE AckDelete { get => GetParam<ACKDELETE>(); set => SetParam(value); }

			/// <summary>Gets the parameter value for this structure.</summary>
			/// <typeparam name="T">The type of the structure to retrieve.</typeparam>
			/// <returns>The requested structure.</returns>
			public unsafe T GetParam<T>() where T : struct
			{
				using var ptr = new PinnedObject(this);
				return ((IntPtr)ptr).ToStructure<T>(Marshal.SizeOf(typeof(CF_OPERATION_PARAMETERS)), 8);
			}

			/// <summary>Sets the parameter value for this structure.</summary>
			/// <typeparam name="T">The type of the structure to set.</typeparam>
			/// <param name="value">The value to set.</param>
			public void SetParam<T>(T value) where T : struct
			{
				unsafe
				{
					fixed (ulong* p = &pad8_16)
					{
						((IntPtr)(void*)p).Write(value, 0, Marshal.SizeOf(typeof(CF_OPERATION_PARAMETERS)) - 8);
					}
				}
			}

			/// <summary>Creates a CF_OPERATION_PARAMETERS instance with the specified parameter value.</summary>
			/// <typeparam name="T">The parameter type.</typeparam>
			/// <param name="paramValue">The parameter value.</param>
			/// <returns>A CF_OPERATION_PARAMETERS instance initialized with <paramref name="paramValue"/> and the correct ParamSize.</returns>
			public static CF_OPERATION_PARAMETERS Create<T>(T paramValue = default) where T : struct
			{
				var op = new CF_OPERATION_PARAMETERS { ParamSize = CF_SIZE_OF_OP_PARAM<T>() };
				op.SetParam(paramValue);
				return op;
			}

			/// <summary>Gets the size value used in ParamSize given a specific parameter type.</summary>
			/// <typeparam name="T">The parameter type.</typeparam>
			/// <returns>The size of the structure.</returns>
			public static uint CF_SIZE_OF_OP_PARAM<T>() where T : struct => (uint)(Marshal.OffsetOf(typeof(CF_OPERATION_PARAMETERS), nameof(pad8_16)).ToInt32() + Marshal.SizeOf(typeof(T)));

			/// <summary/>
			[StructLayout(LayoutKind.Sequential)]
			public struct TRANSFERDATA
			{
				/// <summary>Flags for transferring data.</summary>
				public CF_OPERATION_TRANSFER_DATA_FLAGS Flags;

				/// <summary>Status for transferring data. Set to STATUS_SUCCESS if the sync provider will transfer data to a placeholder.</summary>
				public NTStatus CompletionStatus;

				/// <summary>A valid user mode buffer.</summary>
				public IntPtr Buffer;

				/// <summary>The offset used with the <c>Length</c> to describe a range in the placeholder to which the data is transferred.</summary>
				public long Offset;

				/// <summary>The length in bytes of the <c>Buffer</c>.</summary>
				public long Length;
			}

			/// <summary/>
			[StructLayout(LayoutKind.Sequential)]
			public struct RETRIEVEDATA
			{
				/// <summary>Flags for retrieving data.</summary>
				public CF_OPERATION_RETRIEVE_DATA_FLAGS Flags;

				/// <summary/>
				public IntPtr Buffer;

				/// <summary>The offset used with the <c>Length</c> to describe the range of data retrieved from a placeholder.</summary>
				public long Offset;

				/// <summary>The length in bytes of the <c>Buffer</c>.</summary>
				public long Length;

				/// <summary>The number of bytes retrieved on successful completion.</summary>
				public long ReturnedLength;
			}

			/// <summary/>
			[StructLayout(LayoutKind.Sequential)]
			public struct ACKDATA
			{
				/// <summary>Flags for acknowledging data.</summary>
				public CF_OPERATION_ACK_DATA_FLAGS Flags;

				/// <summary>
				/// <para>Completion status of data acknowledgement.</para>
				/// <para>Set to STATUS_SUCCESS if the sync provider validates the data within the range to be acknowledged is good.</para>
				/// </summary>
				public NTStatus CompletionStatus;

				/// <summary>The offset in bytes of the placeholder data to be acknowledged.</summary>
				public long Offset;

				/// <summary>The length in bytes of data in the placeholder to be acknowledged.</summary>
				public long Length;
			}

			/// <summary/>
			[StructLayout(LayoutKind.Sequential)]
			public struct RESTARTHYDRATION
			{
				/// <summary>Flags to restart placeholder hydration.</summary>
				public CF_OPERATION_RESTART_HYDRATION_FLAGS Flags;

				/// <summary>Optional. Contains updates to the files metadata.</summary>
				public IntPtr FsMetadata;

				/// <summary>Optional. When provided, the file identity is updated to this value. Otherwise, it remains the same.</summary>
				public IntPtr FileIdentity;

				/// <summary>Optional. This specifies the length of the <c>FileIdentity</c>.</summary>
				public uint FileIdentityLength;
			}

			/// <summary/>
			[StructLayout(LayoutKind.Sequential)]
			public struct TRANSFERPLACEHOLDERS
			{
				/// <summary>Flags for transferring placeholders.</summary>
				public CF_OPERATION_TRANSFER_PLACEHOLDERS_FLAGS Flags;

				/// <summary>The completion status of the operation.</summary>
				public NTStatus CompletionStatus;

				/// <summary>Total number of placeholders.</summary>
				public long PlaceholderTotalCount;

				/// <summary>An array of placeholders to be transferred.</summary>
				public IntPtr PlaceholderArray;

				/// <summary>The number of placeholders being transferred.</summary>
				public uint PlaceholderCount;

				/// <summary>The placeholder entries that have been processed.</summary>
				public uint EntriesProcessed;
			}

			/// <summary/>
			[StructLayout(LayoutKind.Sequential)]
			public struct ACKDEHYDRATE
			{
				/// <summary>Dehydrated data acknowledgment flags.</summary>
				public CF_OPERATION_ACK_DEHYDRATE_FLAGS Flags;

				/// <summary>The completion status of the operation.</summary>
				public NTStatus CompletionStatus;

				/// <summary>The file identity of the placeholder file to acknowledge dehydrated data for.</summary>
				public IntPtr FileIdentity;

				/// <summary>Length, in bytes, of the <c>FileIdentity</c>.</summary>
				public uint FileIdentityLength;
			}

			/// <summary/>
			[StructLayout(LayoutKind.Sequential)]
			public struct ACKRENAME
			{
				/// <summary>Acknowledge rename placeholder flags.</summary>
				public CF_OPERATION_ACK_RENAME_FLAGS Flags;

				/// <summary>The completion status of the operation.</summary>
				public NTStatus CompletionStatus;
			}

			/// <summary/>
			[StructLayout(LayoutKind.Sequential)]
			public struct ACKDELETE
			{
				/// <summary>Acknowledge delete flags.</summary>
				public CF_OPERATION_ACK_DELETE_FLAGS Flags;

				/// <summary>The completion status of the operation.</summary>
				public NTStatus CompletionStatus;
			}
		}

		/// <summary>Basic placeholder information.</summary>
		// https://docs.microsoft.com/en-us/windows/win32/api/cfapi/ns-cfapi-cf_placeholder_basic_info typedef struct
		// CF_PLACEHOLDER_BASIC_INFO { CF_PIN_STATE PinState; CF_IN_SYNC_STATE InSyncState; LARGE_INTEGER FileId; LARGE_INTEGER
		// SyncRootFileId; ULONG FileIdentityLength; BYTE FileIdentity[1]; } CF_PLACEHOLDER_BASIC_INFO;
		[PInvokeData("cfapi.h", MSDNShortId = "77367235-342D-4BBC-B910-FE798E14B588")]
		[VanaraMarshaler(typeof(SafeAnysizeStructMarshaler<CF_PLACEHOLDER_BASIC_INFO>), nameof(FileIdentityLength))]
		[StructLayout(LayoutKind.Sequential)]
		public struct CF_PLACEHOLDER_BASIC_INFO
		{
			/// <summary>The pin state of the placeholder. See CfSetPinState for more details.</summary>
			public CF_PIN_STATE PinState;

			/// <summary>The in-sync state of the placeholder. see CfSetInSyncState for more details.</summary>
			public CF_IN_SYNC_STATE InSyncState;

			/// <summary>A 64-bit volume wide non-volatile number that uniquely identifies a file or directory.</summary>
			public long FileId;

			/// <summary>The file ID of the sync root directory that contains the file whose placeholder information is to be queried.</summary>
			public long SyncRootFileId;

			/// <summary>Length, in bytes, of the FileIdentity.</summary>
			public uint FileIdentityLength;

			/// <summary/>
			[MarshalAs(UnmanagedType.ByValArray, SizeConst = 1)]
			public byte[] FileIdentity;
		}

		/// <summary>Contains placeholder information for creating new placeholder files or directories.</summary>
		// https://docs.microsoft.com/en-us/windows/win32/api/cfapi/ns-cfapi-cf_placeholder_create_info typedef struct
		// CF_PLACEHOLDER_CREATE_INFO { LPCWSTR RelativeFileName; CF_FS_METADATA FsMetadata; LPCVOID FileIdentity; DWORD FileIdentityLength;
		// CF_PLACEHOLDER_CREATE_FLAGS Flags; HRESULT Result; USN CreateUsn; } CF_PLACEHOLDER_CREATE_INFO;
		[PInvokeData("cfapi.h", MSDNShortId = "2DC1FF5F-FBFD-45CA-8CD5-B2F586C22778")]
		[StructLayout(LayoutKind.Sequential)]
		public struct CF_PLACEHOLDER_CREATE_INFO
		{
			/// <summary>The name of the child placeholder file or directory to be created.</summary>
			[MarshalAs(UnmanagedType.LPWStr)] public string RelativeFileName;

			/// <summary>File system metadata to be created with the placeholder.</summary>
			public CF_FS_METADATA FsMetadata;

			/// <summary>
			/// A user mode buffer containing file information supplied by the sync provider. This is required for files (not for directories).
			/// </summary>
			public IntPtr FileIdentity;

			/// <summary>Length, in bytes, of the <c>FileIdentity</c>.</summary>
			public uint FileIdentityLength;

			/// <summary>Flags for specifying placeholder creation behavior.</summary>
			public CF_PLACEHOLDER_CREATE_FLAGS Flags;

			/// <summary>The result of placeholder creation. On successful creation, the value is: STATUS_OK.</summary>
			public HRESULT Result;

			/// <summary>The final USN value after create actions are performed.</summary>
			public int CreateUsn;
		}

		/// <summary>Standard placeholder information.</summary>
		// https://docs.microsoft.com/en-us/windows/win32/api/cfapi/ns-cfapi-cf_placeholder_standard_info typedef struct
		// CF_PLACEHOLDER_STANDARD_INFO { LARGE_INTEGER OnDiskDataSize; LARGE_INTEGER ValidatedDataSize; LARGE_INTEGER ModifiedDataSize;
		// LARGE_INTEGER PropertiesSize; CF_PIN_STATE PinState; CF_IN_SYNC_STATE InSyncState; LARGE_INTEGER FileId; LARGE_INTEGER
		// SyncRootFileId; ULONG FileIdentityLength; BYTE FileIdentity[1]; } CF_PLACEHOLDER_STANDARD_INFO;
		[PInvokeData("cfapi.h", MSDNShortId = "F0CDC9CD-7D31-4854-9568-8F13516C6D15")]
		[VanaraMarshaler(typeof(SafeAnysizeStructMarshaler<CF_PLACEHOLDER_STANDARD_INFO>), nameof(FileIdentityLength))]
		[StructLayout(LayoutKind.Sequential)]
		public struct CF_PLACEHOLDER_STANDARD_INFO
		{
			/// <summary>Total number of bytes on disk.</summary>
			public long OnDiskDataSize;

			/// <summary>Total number of bytes in sync with the cloud.</summary>
			public long ValidatedDataSize;

			/// <summary>Total number of bytes that have been overwritten/appended locally that are not in sync with the cloud.</summary>
			public long ModifiedDataSize;

			/// <summary>Total number of bytes on disk that are used by all the property blobs.</summary>
			public long PropertiesSize;

			/// <summary>The pin state of the placeholder. See CfSetPinState for more details.</summary>
			public CF_PIN_STATE PinState;

			/// <summary>The in-sync state of the placeholder. see CfSetInSyncState for more details.</summary>
			public CF_IN_SYNC_STATE InSyncState;

			/// <summary>A 64-bit volume wide non-volatile number that uniquely identifies a file or directory.</summary>
			public long FileId;

			/// <summary>The file ID of the sync root directory that contains the file whose placeholder information is to be queried.</summary>
			public long SyncRootFileId;

			/// <summary>Length, in bytes, of the FileIdentity.</summary>
			public uint FileIdentityLength;

			/// <summary/>
			[MarshalAs(UnmanagedType.ByValArray, SizeConst = 1)]
			public byte[] FileIdentity;
		}

		/// <summary>
		/// Returns information for the cloud files platform. This is intended for sync providers running on multiple versions of Windows.
		/// </summary>
		/// <remarks>
		/// <para>
		/// The platform is a combination of the cloud filter and the placeholder files API library, which are always kept in sync with each
		/// other. This API is intended for sync providers that need to make decisions based on the platform capabilities of multiple
		/// versions of Windows.
		/// </para>
		/// <para>If you are building an app that uses or is aware of placeholder files, this may be useful to you.</para>
		/// </remarks>
		// https://docs.microsoft.com/en-us/windows/win32/api/cfapi/ns-cfapi-cf_platform_info typedef struct CF_PLATFORM_INFO { DWORD
		// BuildNumber; DWORD RevisionNumber; DWORD IntegrationNumber; } CF_PLATFORM_INFO;
		[PInvokeData("cfapi.h", MSDNShortId = "BEB1CBF0-05FB-4D48-AC43-AA957F2208DB")]
		[StructLayout(LayoutKind.Sequential)]
		public struct CF_PLATFORM_INFO
		{
			/// <summary>The build number of the Windows platform version. Changes when the platform is serviced by a Windows update.</summary>
			public uint BuildNumber;

			/// <summary>The revision number of the Windows platform version. Changes when the platform is serviced by a Windows update.</summary>
			public uint RevisionNumber;

			/// <summary>
			/// The integration number of the Windows platform version. This is indicative of the platform capabilities, both in terms of
			/// API contracts and availability of bug fixes.
			/// </summary>
			public uint IntegrationNumber;
		}

		/// <summary>Specifies the primary population policy and its modifier.</summary>
		// https://docs.microsoft.com/en-us/windows/win32/api/cfapi/ns-cfapi-cf_population_policy typedef struct CF_POPULATION_POLICY {
		// CF_POPULATION_POLICY_PRIMARY_USHORT Primary; CF_POPULATION_POLICY_MODIFIER_USHORT Modifier; } CF_POPULATION_POLICY;
		[PInvokeData("cfapi.h", MSDNShortId = "043EBBF8-4077-429B-B959-55E0623520E2")]
		[StructLayout(LayoutKind.Sequential)]
		public struct CF_POPULATION_POLICY
		{
			/// <summary>The primary population policy.</summary>
			public CF_POPULATION_POLICY_PRIMARY Primary;

			/// <summary>The population policy modifier.</summary>
			public CF_POPULATION_POLICY_MODIFIER Modifier;
		}

		/// <summary>Contains information about a user process.</summary>
		// https://docs.microsoft.com/en-us/windows/win32/api/cfapi/ns-cfapi-cf_process_info typedef struct CF_PROCESS_INFO { DWORD
		// StructSize; DWORD ProcessId; PCWSTR ImagePath; PCWSTR PackageName; PCWSTR ApplicationId; PCWSTR CommandLine; DWORD SessionId; } CF_PROCESS_INFO;
		[PInvokeData("cfapi.h", MSDNShortId = "912433E9-DC49-41BA-85F7-1A0AF9F88159")]
		[StructLayout(LayoutKind.Sequential)]
		public struct CF_PROCESS_INFO
		{
			/// <summary>The size of the structure.</summary>
			public uint StructSize;

			/// <summary>The 32 bit ID of the user process.</summary>
			public uint ProcessId;

			/// <summary>
			/// The absolute path of the main executable file including the volume name in the format of NT file path. If the platform
			/// failed to retrieve the image path, “UNKNOWN” will be returned.
			/// </summary>
			[MarshalAs(UnmanagedType.LPWStr)] public string ImagePath;

			/// <summary>Used for modern applications. The app package name.</summary>
			[MarshalAs(UnmanagedType.LPWStr)] public string PackageName;

			/// <summary>Used for modern applications. The application ID.</summary>
			[MarshalAs(UnmanagedType.LPWStr)] public string ApplicationId;

			/// <summary>
			/// <para><c>Note</c> This member was added in Windows 10, version 1803.</para>
			/// <para>Used to start the process. If the platform failed to retrieve the command line, “UNKNOWN” will be returned.</para>
			/// <para>SessionId</para>
			/// <para><c>Note</c> This member was added in Windows 10, version 1803.</para>
			/// <para>The 32bit ID of the session wherein the user process that triggers the callback resides.</para>
			/// </summary>
			[MarshalAs(UnmanagedType.LPWStr)] public string CommandLine;

			/// <summary/>
			public uint SessionId;
		}

		/// <summary>Opaque handle to a request key.</summary>
		[PInvokeData("cfapi.h")]
		[StructLayout(LayoutKind.Sequential)]
		public struct CF_REQUEST_KEY
		{
			private long Internal;
		}

		/// <summary>Defines the sync policies used by a sync root.</summary>
		// https://docs.microsoft.com/en-us/windows/win32/api/cfapi/ns-cfapi-cf_sync_policies typedef struct CF_SYNC_POLICIES { ULONG
		// StructSize; CF_HYDRATION_POLICY Hydration; CF_POPULATION_POLICY Population; CF_INSYNC_POLICY InSync; CF_HARDLINK_POLICY HardLink;
		// } CF_SYNC_POLICIES;
		[PInvokeData("cfapi.h", MSDNShortId = "5BCD0958-1FED-4F97-A4B4-2EB354E85BF6")]
		[StructLayout(LayoutKind.Sequential)]
		public struct CF_SYNC_POLICIES
		{
			/// <summary>The size of the CF_SYNC_POLICIES structure.</summary>
			public uint StructSize;

			/// <summary>The hydration policy.</summary>
			public CF_HYDRATION_POLICY Hydration;

			/// <summary>The population policy.</summary>
			public CF_POPULATION_POLICY Population;

			/// <summary>The in-sync policy.</summary>
			public CF_INSYNC_POLICY InSync;

			/// <summary>The hard link policy.</summary>
			public CF_HARDLINK_POLICY HardLink;
		}

		/// <summary>The details of the sync provider and sync root to be registered.</summary>
		/// <remarks>
		/// <c>SyncRootIdentity</c> and <c>SyncRootIdentityLength</c> are optional members. If not used, set <c>SyncRootIdentity</c> to
		/// <c>nullptr</c> and <c>SyncRootIdentityLength</c> to <c>0</c>. <c>FileIdentity</c> and <c>FileIdentityLength</c> are also
		/// optional and if not used should be set to <c>nullptr</c> and <c>0</c>, respectively.
		/// </remarks>
		// https://docs.microsoft.com/en-us/windows/win32/api/cfapi/ns-cfapi-cf_sync_registration typedef struct CF_SYNC_REGISTRATION {
		// ULONG StructSize; LPCWSTR ProviderName; LPCWSTR ProviderVersion; LPCVOID SyncRootIdentity; DWORD SyncRootIdentityLength; LPCVOID
		// FileIdentity; DWORD FileIdentityLength; GUID ProviderId; } CF_SYNC_REGISTRATION;
		[PInvokeData("cfapi.h", MSDNShortId = "F4D535FA-A0F5-4B4E-8409-0DD13C78A94E")]
		[StructLayout(LayoutKind.Sequential)]
		public struct CF_SYNC_REGISTRATION
		{
			/// <summary>The size of the structure.</summary>
			public uint StructSize;

			/// <summary>The name of the sync provider. This is a user friendly string with a maximum length of 255 characters.</summary>
			[MarshalAs(UnmanagedType.LPWStr)] public string ProviderName;

			/// <summary>The version of the sync provider. This is a user friendly string with a maximum length of 255 characters.</summary>
			[MarshalAs(UnmanagedType.LPWStr)] public string ProviderVersion;

			/// <summary>The sync root identity used by the provider. This member is optional with a maximum size of 64 KB.</summary>
			public IntPtr SyncRootIdentity;

			/// <summary>
			/// The length of the <c>SyncRootIdentity</c>. This member is optional and is only used if a <c>SyncRootIdentity</c> is provided.
			/// </summary>
			public uint SyncRootIdentityLength;

			/// <summary>An optional file identity. This member has a maximum size of 4 KB.</summary>
			public IntPtr FileIdentity;

			/// <summary>The length of the file identity.</summary>
			public uint FileIdentityLength;

			/// <summary/>
			public Guid ProviderId;
		}

		/// <summary>Basic sync root information.</summary>
		// https://docs.microsoft.com/en-us/windows/win32/api/cfapi/ns-cfapi-cf_sync_root_basic_info typedef struct CF_SYNC_ROOT_BASIC_INFO
		// { LARGE_INTEGER SyncRootFileId; } CF_SYNC_ROOT_BASIC_INFO;
		[PInvokeData("cfapi.h", MSDNShortId = "7499D9DD-BAF6-449A-A34E-CEAE3EE10543")]
		[StructLayout(LayoutKind.Sequential)]
		public struct CF_SYNC_ROOT_BASIC_INFO
		{
			/// <summary>The file ID of the sync root.</summary>
			public long SyncRootFileId;
		}

		/// <summary>Sync root provider information.</summary>
		/// <remarks><c>CF_MAX_PROVIDER_NAME_LENGTH</c> and <c>CF_MAX_PROVIDER_VERSION_LENGTH</c> are set to 255.</remarks>
		// https://docs.microsoft.com/en-us/windows/win32/api/cfapi/ns-cfapi-cf_sync_root_provider_info typedef struct
		// CF_SYNC_ROOT_PROVIDER_INFO { CF_SYNC_PROVIDER_STATUS ProviderStatus; WCHAR ProviderName[CF_MAX_PROVIDER_NAME_LENGTH + 1]; WCHAR
		// ProviderVersion[CF_MAX_PROVIDER_VERSION_LENGTH + 1]; } CF_SYNC_ROOT_PROVIDER_INFO;
		[PInvokeData("cfapi.h", MSDNShortId = "9EBC64B5-7FB3-41AA-BCB2-29B3E444B463")]
		[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
		public struct CF_SYNC_ROOT_PROVIDER_INFO
		{
			/// <summary>Status of the sync root provider.</summary>
			public CF_SYNC_PROVIDER_STATUS ProviderStatus;

			/// <summary/>
			[MarshalAs(UnmanagedType.ByValTStr, SizeConst = CF_MAX_PROVIDER_NAME_LENGTH + 1)]
			public string ProviderName;

			/// <summary/>
			[MarshalAs(UnmanagedType.ByValTStr, SizeConst = CF_MAX_PROVIDER_VERSION_LENGTH + 1)]
			public string ProviderVersion;
		}

		/// <summary>Standard sync root information.</summary>
		/// <remarks><c>CF_MAX_PROVIDER_NAME_LENGTH</c> and <c>CF_MAX_PROVIDER_VERSION_LENGTH</c> are set to 255.</remarks>
		// https://docs.microsoft.com/en-us/windows/win32/api/cfapi/ns-cfapi-cf_sync_root_standard_info typedef struct
		// CF_SYNC_ROOT_STANDARD_INFO { LARGE_INTEGER SyncRootFileId; CF_HYDRATION_POLICY HydrationPolicy; CF_POPULATION_POLICY
		// PopulationPolicy; CF_INSYNC_POLICY InSyncPolicy; CF_HARDLINK_POLICY HardLinkPolicy; CF_SYNC_PROVIDER_STATUS ProviderStatus; WCHAR
		// ProviderName[CF_MAX_PROVIDER_NAME_LENGTH + 1]; WCHAR ProviderVersion[CF_MAX_PROVIDER_VERSION_LENGTH + 1]; ULONG
		// SyncRootIdentityLength; BYTE SyncRootIdentity[1]; } CF_SYNC_ROOT_STANDARD_INFO;
		[PInvokeData("cfapi.h", MSDNShortId = "17E409FB-2997-432C-977F-BEBF53068B42")]
		[VanaraMarshaler(typeof(SafeAnysizeStructMarshaler<CF_SYNC_ROOT_STANDARD_INFO>), nameof(SyncRootIdentityLength))]
		[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
		public struct CF_SYNC_ROOT_STANDARD_INFO
		{
			/// <summary>File ID of the sync root.</summary>
			public long SyncRootFileId;

			/// <summary>Hydration policy of the sync root.</summary>
			public CF_HYDRATION_POLICY HydrationPolicy;

			/// <summary>Population policy of the sync root.</summary>
			public CF_POPULATION_POLICY PopulationPolicy;

			/// <summary>In-sync policy of the sync root.</summary>
			public CF_INSYNC_POLICY InSyncPolicy;

			/// <summary>Sync root hard linking policy.</summary>
			public CF_HARDLINK_POLICY HardLinkPolicy;

			/// <summary>Status of the sync root provider.</summary>
			public CF_SYNC_PROVIDER_STATUS ProviderStatus;

			/// <summary/>
			[MarshalAs(UnmanagedType.ByValTStr, SizeConst = CF_MAX_PROVIDER_NAME_LENGTH + 1)]
			public string ProviderName;

			/// <summary/>
			[MarshalAs(UnmanagedType.ByValTStr, SizeConst = CF_MAX_PROVIDER_VERSION_LENGTH + 1)]
			public string ProviderVersion;

			/// <summary>Length, in bytes, of the SyncRootIdentity.</summary>
			public uint SyncRootIdentityLength;

			/// <summary/>
			[MarshalAs(UnmanagedType.ByValArray, SizeConst = 1)]
			public byte[] SyncRootIdentity;
		}

		/// <summary>Used in a CF_OPERATION_INFO structure to describe the status of a specified sync root.</summary>
		/// <remarks>
		/// If a null pointer is set in the <c>SyncStatus</c> field of a CF_OPERATION_INFO structure, the platform will clear the previously
		/// set sync status, if there is one.
		/// </remarks>
		// https://docs.microsoft.com/en-us/windows/win32/api/cfapi/ns-cfapi-cf_sync_status typedef struct CF_SYNC_STATUS { ULONG
		// StructSize; ULONG Code; ULONG DescriptionOffset; ULONG DescriptionLength; ULONG DeviceIdOffset; ULONG DeviceIdLength; } CF_SYNC_STATUS;
		[PInvokeData("cfapi.h", MSDNShortId = "F80CBBAE-605B-4C1E-BDA5-A4B155F9D079")]
		[StructLayout(LayoutKind.Sequential)]
		public struct CF_SYNC_STATUS
		{
			/// <summary>The size, in bytes, of the sync status structure, including the actual description string.</summary>
			public uint StructSize;

			/// <summary>
			/// <para>The use of this parameter is completely up to the sync provider that supports this rich sync status construct.</para>
			/// <para>For a particular sync provider, it is expected that there is a 1:1 mapping between the code and the description string.</para>
			/// <para>
			/// It is recommended that you use the highest bit order to describe the type of error code: 1 for an error-level code, and 0
			/// for an information-level code.
			/// </para>
			/// <para><c>Note</c><c>Code</c> is opaque to the platform, and is used only for tracking purposes.</para>
			/// </summary>
			public uint Code;

			/// <summary>
			/// The offset of the description string relative to the start of <c>CF_SYNC_STATUS</c>. It points to a localized
			/// null-terminated wide string that is expected to contain more meaningful and actionable information about the file in
			/// question. Sync providers are expected to balance the requirement of providing more actionable information and maintaining an
			/// as small as possible memory footprint.
			/// </summary>
			public uint DescriptionOffset;

			/// <summary>The size of the description string, in bytes, that includes the null terminator.</summary>
			public uint DescriptionLength;

			/// <summary/>
			public uint DeviceIdOffset;

			/// <summary/>
			public uint DeviceIdLength;
		}

		/// <summary>Opaque handle to a transfer key.</summary>
		[PInvokeData("cfapi.h")]
		[StructLayout(LayoutKind.Sequential)]
		public struct CF_TRANSFER_KEY
		{
			private long Internal;
		}
	}
}