// ------------------------------------------------------------------------------
// <auto-generated>
//     This code was generated by a tool.
//
//     Changes to this file may cause incorrect behavior and will be lost if
//     the code is regenerated.
// </auto-generated>
// ------------------------------------------------------------------------------

namespace Win32.Graphics.Direct2D;

public static partial class Apis
{
	public const float D2D1_DEFAULT_FLATTENING_TOLERANCE = 0.25f;

	public static ref readonly Guid CLSID_D2D12DAffineTransform
	{
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		get
		{
			ReadOnlySpan<byte> data = new byte[] {
				0x85, 0x74, 0xA9, 0x6A,
				0x54, 0x63,
				0xFC, 0x4C,
				0x90,
				0x8C,
				0xE4,
				0xA7,
				0x4F,
				0x62,
				0xC9,
				0x6C
			};

			Debug.Assert(data.Length == Unsafe.SizeOf<Guid>());
			return ref Unsafe.As<byte, Guid>(ref MemoryMarshal.GetReference(data));
		}
	}

	public static ref readonly Guid CLSID_D2D13DPerspectiveTransform
	{
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		get
		{
			ReadOnlySpan<byte> data = new byte[] {
				0x0B, 0x4D, 0x84, 0xC2,
				0x86, 0x3D,
				0xE7, 0x46,
				0x85,
				0xBA,
				0x52,
				0x6C,
				0x92,
				0x40,
				0xF3,
				0xFB
			};

			Debug.Assert(data.Length == Unsafe.SizeOf<Guid>());
			return ref Unsafe.As<byte, Guid>(ref MemoryMarshal.GetReference(data));
		}
	}

	public static ref readonly Guid CLSID_D2D13DTransform
	{
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		get
		{
			ReadOnlySpan<byte> data = new byte[] {
				0x04, 0x7B, 0x46, 0xE8,
				0x61, 0xEC,
				0x8A, 0x4B,
				0xB5,
				0xDE,
				0xD4,
				0xD7,
				0x3D,
				0xEB,
				0xEA,
				0x5A
			};

			Debug.Assert(data.Length == Unsafe.SizeOf<Guid>());
			return ref Unsafe.As<byte, Guid>(ref MemoryMarshal.GetReference(data));
		}
	}

	public static ref readonly Guid CLSID_D2D1ArithmeticComposite
	{
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		get
		{
			ReadOnlySpan<byte> data = new byte[] {
				0x37, 0x14, 0x15, 0xFC,
				0x9A, 0x04,
				0x84, 0x47,
				0xA2,
				0x4A,
				0xF1,
				0xC4,
				0xDA,
				0xF2,
				0x09,
				0x87
			};

			Debug.Assert(data.Length == Unsafe.SizeOf<Guid>());
			return ref Unsafe.As<byte, Guid>(ref MemoryMarshal.GetReference(data));
		}
	}

	public static ref readonly Guid CLSID_D2D1Atlas
	{
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		get
		{
			ReadOnlySpan<byte> data = new byte[] {
				0xE4, 0x2B, 0x3E, 0x91,
				0xCF, 0xFD,
				0xE2, 0x4F,
				0xA5,
				0xF0,
				0x24,
				0x54,
				0xF1,
				0x4F,
				0xF4,
				0x08
			};

			Debug.Assert(data.Length == Unsafe.SizeOf<Guid>());
			return ref Unsafe.As<byte, Guid>(ref MemoryMarshal.GetReference(data));
		}
	}

	public static ref readonly Guid CLSID_D2D1BitmapSource
	{
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		get
		{
			ReadOnlySpan<byte> data = new byte[] {
				0x4D, 0xC2, 0xB6, 0x5F,
				0xDD, 0xC6,
				0x31, 0x42,
				0x94,
				0x04,
				0x50,
				0xF4,
				0xD5,
				0xC3,
				0x25,
				0x2D
			};

			Debug.Assert(data.Length == Unsafe.SizeOf<Guid>());
			return ref Unsafe.As<byte, Guid>(ref MemoryMarshal.GetReference(data));
		}
	}

	public static ref readonly Guid CLSID_D2D1Blend
	{
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		get
		{
			ReadOnlySpan<byte> data = new byte[] {
				0x7B, 0xB7, 0xC5, 0x81,
				0xF8, 0x13,
				0xDD, 0x4C,
				0xAD,
				0x20,
				0xC8,
				0x90,
				0x54,
				0x7A,
				0xC6,
				0x5D
			};

			Debug.Assert(data.Length == Unsafe.SizeOf<Guid>());
			return ref Unsafe.As<byte, Guid>(ref MemoryMarshal.GetReference(data));
		}
	}

	public static ref readonly Guid CLSID_D2D1Border
	{
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		get
		{
			ReadOnlySpan<byte> data = new byte[] {
				0xC0, 0x49, 0x2D, 0x2A,
				0xCF, 0x4A,
				0xC7, 0x43,
				0x8C,
				0x6A,
				0x7C,
				0x4A,
				0x27,
				0x87,
				0x4D,
				0x27
			};

			Debug.Assert(data.Length == Unsafe.SizeOf<Guid>());
			return ref Unsafe.As<byte, Guid>(ref MemoryMarshal.GetReference(data));
		}
	}

	public static ref readonly Guid CLSID_D2D1Brightness
	{
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		get
		{
			ReadOnlySpan<byte> data = new byte[] {
				0x1E, 0x8D, 0xEA, 0x8C,
				0xB0, 0x77,
				0x86, 0x49,
				0xB3,
				0xB9,
				0x2F,
				0x0C,
				0x0E,
				0xAE,
				0x78,
				0x87
			};

			Debug.Assert(data.Length == Unsafe.SizeOf<Guid>());
			return ref Unsafe.As<byte, Guid>(ref MemoryMarshal.GetReference(data));
		}
	}

	public static ref readonly Guid CLSID_D2D1ColorManagement
	{
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		get
		{
			ReadOnlySpan<byte> data = new byte[] {
				0x4C, 0x52, 0x28, 0x1A,
				0xD6, 0xFD,
				0xA4, 0x4A,
				0xAE,
				0x8F,
				0x83,
				0x7E,
				0xB8,
				0x26,
				0x7B,
				0x37
			};

			Debug.Assert(data.Length == Unsafe.SizeOf<Guid>());
			return ref Unsafe.As<byte, Guid>(ref MemoryMarshal.GetReference(data));
		}
	}

	public static ref readonly Guid CLSID_D2D1ColorMatrix
	{
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		get
		{
			ReadOnlySpan<byte> data = new byte[] {
				0xD6, 0x03, 0x1F, 0x92,
				0x1C, 0x64,
				0xDF, 0x47,
				0x85,
				0x2D,
				0xB4,
				0xBB,
				0x61,
				0x53,
				0xAE,
				0x11
			};

			Debug.Assert(data.Length == Unsafe.SizeOf<Guid>());
			return ref Unsafe.As<byte, Guid>(ref MemoryMarshal.GetReference(data));
		}
	}

	public static ref readonly Guid CLSID_D2D1Composite
	{
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		get
		{
			ReadOnlySpan<byte> data = new byte[] {
				0x51, 0x9F, 0xFC, 0x48,
				0xAC, 0xF6,
				0xF1, 0x48,
				0x8B,
				0x58,
				0x3B,
				0x28,
				0xAC,
				0x46,
				0xF7,
				0x6D
			};

			Debug.Assert(data.Length == Unsafe.SizeOf<Guid>());
			return ref Unsafe.As<byte, Guid>(ref MemoryMarshal.GetReference(data));
		}
	}

	public static ref readonly Guid CLSID_D2D1ConvolveMatrix
	{
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		get
		{
			ReadOnlySpan<byte> data = new byte[] {
				0x08, 0x8C, 0x7F, 0x40,
				0x33, 0x55,
				0x31, 0x43,
				0xA3,
				0x41,
				0x23,
				0xCC,
				0x38,
				0x77,
				0x84,
				0x3E
			};

			Debug.Assert(data.Length == Unsafe.SizeOf<Guid>());
			return ref Unsafe.As<byte, Guid>(ref MemoryMarshal.GetReference(data));
		}
	}

	public static ref readonly Guid CLSID_D2D1Crop
	{
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		get
		{
			ReadOnlySpan<byte> data = new byte[] {
				0x10, 0x71, 0x3F, 0xE2,
				0x9A, 0x0E,
				0x24, 0x43,
				0xAF,
				0x47,
				0x6A,
				0x2C,
				0x0C,
				0x46,
				0xF3,
				0x5B
			};

			Debug.Assert(data.Length == Unsafe.SizeOf<Guid>());
			return ref Unsafe.As<byte, Guid>(ref MemoryMarshal.GetReference(data));
		}
	}

	public static ref readonly Guid CLSID_D2D1DirectionalBlur
	{
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		get
		{
			ReadOnlySpan<byte> data = new byte[] {
				0xA6, 0x19, 0x43, 0x17,
				0xE9, 0x58,
				0xB2, 0x49,
				0xBB,
				0x63,
				0xCA,
				0xF2,
				0xC8,
				0x11,
				0xA3,
				0xDB
			};

			Debug.Assert(data.Length == Unsafe.SizeOf<Guid>());
			return ref Unsafe.As<byte, Guid>(ref MemoryMarshal.GetReference(data));
		}
	}

	public static ref readonly Guid CLSID_D2D1DiscreteTransfer
	{
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		get
		{
			ReadOnlySpan<byte> data = new byte[] {
				0xCD, 0x6F, 0x86, 0x90,
				0x8E, 0x48,
				0x4B, 0x45,
				0xAF,
				0x06,
				0xE5,
				0x04,
				0x1B,
				0x66,
				0xC3,
				0x6C
			};

			Debug.Assert(data.Length == Unsafe.SizeOf<Guid>());
			return ref Unsafe.As<byte, Guid>(ref MemoryMarshal.GetReference(data));
		}
	}

	public static ref readonly Guid CLSID_D2D1DisplacementMap
	{
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		get
		{
			ReadOnlySpan<byte> data = new byte[] {
				0x64, 0x83, 0xC4, 0xED,
				0x17, 0x04,
				0x11, 0x41,
				0x94,
				0x50,
				0x43,
				0x84,
				0x5F,
				0xA9,
				0xF8,
				0x90
			};

			Debug.Assert(data.Length == Unsafe.SizeOf<Guid>());
			return ref Unsafe.As<byte, Guid>(ref MemoryMarshal.GetReference(data));
		}
	}

	public static ref readonly Guid CLSID_D2D1DistantDiffuse
	{
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		get
		{
			ReadOnlySpan<byte> data = new byte[] {
				0x62, 0xFD, 0x7E, 0x3E,
				0x2D, 0xA3,
				0xD4, 0x46,
				0xA8,
				0x3C,
				0x52,
				0x78,
				0x88,
				0x9A,
				0xC9,
				0x54
			};

			Debug.Assert(data.Length == Unsafe.SizeOf<Guid>());
			return ref Unsafe.As<byte, Guid>(ref MemoryMarshal.GetReference(data));
		}
	}

	public static ref readonly Guid CLSID_D2D1DistantSpecular
	{
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		get
		{
			ReadOnlySpan<byte> data = new byte[] {
				0xE5, 0x1E, 0x8C, 0x42,
				0xB8, 0x77,
				0x50, 0x44,
				0x8A,
				0xB5,
				0x72,
				0x21,
				0x9C,
				0x21,
				0xAB,
				0xDA
			};

			Debug.Assert(data.Length == Unsafe.SizeOf<Guid>());
			return ref Unsafe.As<byte, Guid>(ref MemoryMarshal.GetReference(data));
		}
	}

	public static ref readonly Guid CLSID_D2D1DpiCompensation
	{
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		get
		{
			ReadOnlySpan<byte> data = new byte[] {
				0xC7, 0xC5, 0x26, 0x6C,
				0xE0, 0x34,
				0xFC, 0x46,
				0x9C,
				0xFD,
				0xE5,
				0x82,
				0x37,
				0x06,
				0xE2,
				0x28
			};

			Debug.Assert(data.Length == Unsafe.SizeOf<Guid>());
			return ref Unsafe.As<byte, Guid>(ref MemoryMarshal.GetReference(data));
		}
	}

	public static ref readonly Guid CLSID_D2D1Flood
	{
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		get
		{
			ReadOnlySpan<byte> data = new byte[] {
				0x20, 0x3C, 0xC2, 0x61,
				0x69, 0xAE,
				0x8E, 0x4D,
				0x94,
				0xCF,
				0x50,
				0x07,
				0x8D,
				0xF6,
				0x38,
				0xF2
			};

			Debug.Assert(data.Length == Unsafe.SizeOf<Guid>());
			return ref Unsafe.As<byte, Guid>(ref MemoryMarshal.GetReference(data));
		}
	}

	public static ref readonly Guid CLSID_D2D1GammaTransfer
	{
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		get
		{
			ReadOnlySpan<byte> data = new byte[] {
				0xC4, 0x44, 0x94, 0x40,
				0x19, 0xC4,
				0xA0, 0x41,
				0xB0,
				0xC1,
				0x8C,
				0xD0,
				0xC0,
				0xA1,
				0x8E,
				0x42
			};

			Debug.Assert(data.Length == Unsafe.SizeOf<Guid>());
			return ref Unsafe.As<byte, Guid>(ref MemoryMarshal.GetReference(data));
		}
	}

	public static ref readonly Guid CLSID_D2D1GaussianBlur
	{
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		get
		{
			ReadOnlySpan<byte> data = new byte[] {
				0x69, 0x6D, 0xEB, 0x1F,
				0xE6, 0x2F,
				0xC9, 0x4A,
				0x8C,
				0x58,
				0x1D,
				0x7F,
				0x93,
				0xE7,
				0xA6,
				0xA5
			};

			Debug.Assert(data.Length == Unsafe.SizeOf<Guid>());
			return ref Unsafe.As<byte, Guid>(ref MemoryMarshal.GetReference(data));
		}
	}

	public static ref readonly Guid CLSID_D2D1Scale
	{
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		get
		{
			ReadOnlySpan<byte> data = new byte[] {
				0x69, 0x93, 0xAF, 0x9D,
				0x46, 0x38,
				0x0E, 0x4D,
				0xA4,
				0x4E,
				0x0C,
				0x60,
				0x79,
				0x34,
				0xA5,
				0xD7
			};

			Debug.Assert(data.Length == Unsafe.SizeOf<Guid>());
			return ref Unsafe.As<byte, Guid>(ref MemoryMarshal.GetReference(data));
		}
	}

	public static ref readonly Guid CLSID_D2D1Histogram
	{
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		get
		{
			ReadOnlySpan<byte> data = new byte[] {
				0xD0, 0xB7, 0x1D, 0x88,
				0xEE, 0xF7,
				0x4D, 0x4D,
				0xA6,
				0xD2,
				0x46,
				0x97,
				0xAC,
				0xC6,
				0x6E,
				0xE8
			};

			Debug.Assert(data.Length == Unsafe.SizeOf<Guid>());
			return ref Unsafe.As<byte, Guid>(ref MemoryMarshal.GetReference(data));
		}
	}

	public static ref readonly Guid CLSID_D2D1HueRotation
	{
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		get
		{
			ReadOnlySpan<byte> data = new byte[] {
				0xEC, 0x58, 0x44, 0x0F,
				0x32, 0x4B,
				0x1B, 0x49,
				0x9E,
				0x85,
				0xBD,
				0x73,
				0xF4,
				0x4D,
				0x3E,
				0xB6
			};

			Debug.Assert(data.Length == Unsafe.SizeOf<Guid>());
			return ref Unsafe.As<byte, Guid>(ref MemoryMarshal.GetReference(data));
		}
	}

	public static ref readonly Guid CLSID_D2D1LinearTransfer
	{
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		get
		{
			ReadOnlySpan<byte> data = new byte[] {
				0xFD, 0xC8, 0x47, 0xAD,
				0xEF, 0x63,
				0xCC, 0x4A,
				0x9B,
				0x51,
				0x67,
				0x97,
				0x9C,
				0x03,
				0x6C,
				0x06
			};

			Debug.Assert(data.Length == Unsafe.SizeOf<Guid>());
			return ref Unsafe.As<byte, Guid>(ref MemoryMarshal.GetReference(data));
		}
	}

	public static ref readonly Guid CLSID_D2D1LuminanceToAlpha
	{
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		get
		{
			ReadOnlySpan<byte> data = new byte[] {
				0xB7, 0x1A, 0x25, 0x41,
				0xEB, 0x0B,
				0xF8, 0x46,
				0x9D,
				0xA7,
				0x59,
				0xE9,
				0x3F,
				0xCC,
				0xE5,
				0xDE
			};

			Debug.Assert(data.Length == Unsafe.SizeOf<Guid>());
			return ref Unsafe.As<byte, Guid>(ref MemoryMarshal.GetReference(data));
		}
	}

	public static ref readonly Guid CLSID_D2D1Morphology
	{
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		get
		{
			ReadOnlySpan<byte> data = new byte[] {
				0x0D, 0xC4, 0xE6, 0xEA,
				0x6A, 0x62,
				0x2D, 0x4C,
				0xBF,
				0xCB,
				0x39,
				0x10,
				0x01,
				0xAB,
				0xE2,
				0x02
			};

			Debug.Assert(data.Length == Unsafe.SizeOf<Guid>());
			return ref Unsafe.As<byte, Guid>(ref MemoryMarshal.GetReference(data));
		}
	}

	public static ref readonly Guid CLSID_D2D1OpacityMetadata
	{
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		get
		{
			ReadOnlySpan<byte> data = new byte[] {
				0x6A, 0x00, 0x53, 0x6C,
				0x50, 0x44,
				0x99, 0x41,
				0xAA,
				0x5B,
				0xAD,
				0x16,
				0x56,
				0xFE,
				0xCE,
				0x5E
			};

			Debug.Assert(data.Length == Unsafe.SizeOf<Guid>());
			return ref Unsafe.As<byte, Guid>(ref MemoryMarshal.GetReference(data));
		}
	}

	public static ref readonly Guid CLSID_D2D1PointDiffuse
	{
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		get
		{
			ReadOnlySpan<byte> data = new byte[] {
				0xC3, 0x03, 0xE3, 0xB9,
				0x8C, 0xC0,
				0x91, 0x4F,
				0x8B,
				0x7B,
				0x38,
				0x65,
				0x6B,
				0xC4,
				0x8C,
				0x20
			};

			Debug.Assert(data.Length == Unsafe.SizeOf<Guid>());
			return ref Unsafe.As<byte, Guid>(ref MemoryMarshal.GetReference(data));
		}
	}

	public static ref readonly Guid CLSID_D2D1PointSpecular
	{
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		get
		{
			ReadOnlySpan<byte> data = new byte[] {
				0x26, 0xCA, 0xC3, 0x09,
				0xE2, 0x3A,
				0x09, 0x4F,
				0x9E,
				0xBC,
				0xED,
				0x38,
				0x65,
				0xD5,
				0x3F,
				0x22
			};

			Debug.Assert(data.Length == Unsafe.SizeOf<Guid>());
			return ref Unsafe.As<byte, Guid>(ref MemoryMarshal.GetReference(data));
		}
	}

	public static ref readonly Guid CLSID_D2D1Premultiply
	{
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		get
		{
			ReadOnlySpan<byte> data = new byte[] {
				0x19, 0xB4, 0xEA, 0x06,
				0xED, 0xDE,
				0x18, 0x40,
				0x80,
				0xD2,
				0x3E,
				0x1D,
				0x47,
				0x1A,
				0xDE,
				0xB2
			};

			Debug.Assert(data.Length == Unsafe.SizeOf<Guid>());
			return ref Unsafe.As<byte, Guid>(ref MemoryMarshal.GetReference(data));
		}
	}

	public static ref readonly Guid CLSID_D2D1Saturation
	{
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		get
		{
			ReadOnlySpan<byte> data = new byte[] {
				0xCF, 0xD9, 0xB2, 0x5C,
				0x7D, 0x32,
				0x9F, 0x45,
				0xA0,
				0xCE,
				0x40,
				0xC0,
				0xB2,
				0x08,
				0x6B,
				0xF7
			};

			Debug.Assert(data.Length == Unsafe.SizeOf<Guid>());
			return ref Unsafe.As<byte, Guid>(ref MemoryMarshal.GetReference(data));
		}
	}

	public static ref readonly Guid CLSID_D2D1Shadow
	{
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		get
		{
			ReadOnlySpan<byte> data = new byte[] {
				0x61, 0xA3, 0x7E, 0xC6,
				0x63, 0x18,
				0x69, 0x4E,
				0x89,
				0xDB,
				0x69,
				0x5D,
				0x3E,
				0x9A,
				0x5B,
				0x6B
			};

			Debug.Assert(data.Length == Unsafe.SizeOf<Guid>());
			return ref Unsafe.As<byte, Guid>(ref MemoryMarshal.GetReference(data));
		}
	}

	public static ref readonly Guid CLSID_D2D1SpotDiffuse
	{
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		get
		{
			ReadOnlySpan<byte> data = new byte[] {
				0x05, 0x11, 0x8A, 0x81,
				0x32, 0x79,
				0xF4, 0x44,
				0xAA,
				0x86,
				0x08,
				0xAE,
				0x7B,
				0x2F,
				0x2C,
				0x93
			};

			Debug.Assert(data.Length == Unsafe.SizeOf<Guid>());
			return ref Unsafe.As<byte, Guid>(ref MemoryMarshal.GetReference(data));
		}
	}

	public static ref readonly Guid CLSID_D2D1SpotSpecular
	{
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		get
		{
			ReadOnlySpan<byte> data = new byte[] {
				0x1E, 0x42, 0xAE, 0xED,
				0x54, 0x76,
				0x37, 0x4A,
				0x9D,
				0xB8,
				0x71,
				0xAC,
				0xC1,
				0xBE,
				0xB3,
				0xC1
			};

			Debug.Assert(data.Length == Unsafe.SizeOf<Guid>());
			return ref Unsafe.As<byte, Guid>(ref MemoryMarshal.GetReference(data));
		}
	}

	public static ref readonly Guid CLSID_D2D1TableTransfer
	{
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		get
		{
			ReadOnlySpan<byte> data = new byte[] {
				0xC3, 0x18, 0xF8, 0x5B,
				0x43, 0x5E,
				0xCB, 0x48,
				0xB6,
				0x31,
				0x86,
				0x83,
				0x96,
				0xD6,
				0xA1,
				0xD4
			};

			Debug.Assert(data.Length == Unsafe.SizeOf<Guid>());
			return ref Unsafe.As<byte, Guid>(ref MemoryMarshal.GetReference(data));
		}
	}

	public static ref readonly Guid CLSID_D2D1Tile
	{
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		get
		{
			ReadOnlySpan<byte> data = new byte[] {
				0x38, 0x41, 0x78, 0xB0,
				0x76, 0x3B,
				0xC5, 0x4B,
				0xB1,
				0x3B,
				0x0F,
				0xA2,
				0xAD,
				0x02,
				0x65,
				0x9F
			};

			Debug.Assert(data.Length == Unsafe.SizeOf<Guid>());
			return ref Unsafe.As<byte, Guid>(ref MemoryMarshal.GetReference(data));
		}
	}

	public static ref readonly Guid CLSID_D2D1Turbulence
	{
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		get
		{
			ReadOnlySpan<byte> data = new byte[] {
				0xAE, 0xB6, 0x2B, 0xCF,
				0x9A, 0x88,
				0xD7, 0x4A,
				0xBA,
				0x29,
				0xA2,
				0xFD,
				0x73,
				0x2C,
				0x9F,
				0xC9
			};

			Debug.Assert(data.Length == Unsafe.SizeOf<Guid>());
			return ref Unsafe.As<byte, Guid>(ref MemoryMarshal.GetReference(data));
		}
	}

	public static ref readonly Guid CLSID_D2D1UnPremultiply
	{
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		get
		{
			ReadOnlySpan<byte> data = new byte[] {
				0x89, 0xC4, 0x9A, 0xFB,
				0x8D, 0xAD,
				0xED, 0x41,
				0x99,
				0x99,
				0xBB,
				0x63,
				0x47,
				0xD1,
				0x10,
				0xF7
			};

			Debug.Assert(data.Length == Unsafe.SizeOf<Guid>());
			return ref Unsafe.As<byte, Guid>(ref MemoryMarshal.GetReference(data));
		}
	}

	public static ref readonly Guid CLSID_D2D1YCbCr
	{
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		get
		{
			ReadOnlySpan<byte> data = new byte[] {
				0xC1, 0x3C, 0x50, 0x99,
				0xC7, 0x66,
				0xC9, 0x45,
				0xA8,
				0x75,
				0x8A,
				0xD8,
				0xA7,
				0x91,
				0x44,
				0x01
			};

			Debug.Assert(data.Length == Unsafe.SizeOf<Guid>());
			return ref Unsafe.As<byte, Guid>(ref MemoryMarshal.GetReference(data));
		}
	}

	public static ref readonly Guid CLSID_D2D1Contrast
	{
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		get
		{
			ReadOnlySpan<byte> data = new byte[] {
				0x8A, 0xA7, 0x48, 0xB6,
				0xD5, 0x0E,
				0x80, 0x4F,
				0xA9,
				0x4A,
				0x8E,
				0x82,
				0x5A,
				0xCA,
				0x6B,
				0x77
			};

			Debug.Assert(data.Length == Unsafe.SizeOf<Guid>());
			return ref Unsafe.As<byte, Guid>(ref MemoryMarshal.GetReference(data));
		}
	}

	public static ref readonly Guid CLSID_D2D1RgbToHue
	{
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		get
		{
			ReadOnlySpan<byte> data = new byte[] {
				0xEC, 0xE5, 0xF3, 0x23,
				0xE8, 0x91,
				0x3D, 0x4D,
				0xAD,
				0x0A,
				0xAF,
				0xAD,
				0xC1,
				0x00,
				0x4A,
				0xA1
			};

			Debug.Assert(data.Length == Unsafe.SizeOf<Guid>());
			return ref Unsafe.As<byte, Guid>(ref MemoryMarshal.GetReference(data));
		}
	}

	public static ref readonly Guid CLSID_D2D1HueToRgb
	{
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		get
		{
			ReadOnlySpan<byte> data = new byte[] {
				0xBD, 0xA6, 0x78, 0x7B,
				0x41, 0x01,
				0xEF, 0x4D,
				0x8A,
				0x52,
				0x63,
				0x56,
				0xEE,
				0x0C,
				0xBD,
				0xD5
			};

			Debug.Assert(data.Length == Unsafe.SizeOf<Guid>());
			return ref Unsafe.As<byte, Guid>(ref MemoryMarshal.GetReference(data));
		}
	}

	public static ref readonly Guid CLSID_D2D1ChromaKey
	{
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		get
		{
			ReadOnlySpan<byte> data = new byte[] {
				0x5B, 0x1F, 0xC0, 0x74,
				0x0D, 0x2A,
				0x8C, 0x40,
				0x88,
				0xE2,
				0xC7,
				0xA3,
				0xC7,
				0x19,
				0x77,
				0x42
			};

			Debug.Assert(data.Length == Unsafe.SizeOf<Guid>());
			return ref Unsafe.As<byte, Guid>(ref MemoryMarshal.GetReference(data));
		}
	}

	public static ref readonly Guid CLSID_D2D1Emboss
	{
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		get
		{
			ReadOnlySpan<byte> data = new byte[] {
				0x2B, 0xEB, 0xC5, 0xB1,
				0x48, 0x03,
				0xF0, 0x43,
				0x81,
				0x07,
				0x49,
				0x57,
				0xCA,
				0xCB,
				0xA2,
				0xAE
			};

			Debug.Assert(data.Length == Unsafe.SizeOf<Guid>());
			return ref Unsafe.As<byte, Guid>(ref MemoryMarshal.GetReference(data));
		}
	}

	public static ref readonly Guid CLSID_D2D1Exposure
	{
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		get
		{
			ReadOnlySpan<byte> data = new byte[] {
				0xFA, 0x8C, 0x6C, 0xB5,
				0x34, 0xF6,
				0xEE, 0x41,
				0xBE,
				0xE0,
				0xFF,
				0xA6,
				0x17,
				0x10,
				0x60,
				0x04
			};

			Debug.Assert(data.Length == Unsafe.SizeOf<Guid>());
			return ref Unsafe.As<byte, Guid>(ref MemoryMarshal.GetReference(data));
		}
	}

	public static ref readonly Guid CLSID_D2D1Grayscale
	{
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		get
		{
			ReadOnlySpan<byte> data = new byte[] {
				0xEB, 0xE0, 0xDD, 0x36,
				0x25, 0x37,
				0xE0, 0x42,
				0x83,
				0x6D,
				0x52,
				0xFB,
				0x20,
				0xAE,
				0xE6,
				0x44
			};

			Debug.Assert(data.Length == Unsafe.SizeOf<Guid>());
			return ref Unsafe.As<byte, Guid>(ref MemoryMarshal.GetReference(data));
		}
	}

	public static ref readonly Guid CLSID_D2D1Invert
	{
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		get
		{
			ReadOnlySpan<byte> data = new byte[] {
				0x4D, 0x78, 0xC3, 0xE0,
				0x39, 0xCB,
				0x84, 0x4E,
				0xB6,
				0xFD,
				0x6B,
				0x72,
				0xF0,
				0x81,
				0x02,
				0x63
			};

			Debug.Assert(data.Length == Unsafe.SizeOf<Guid>());
			return ref Unsafe.As<byte, Guid>(ref MemoryMarshal.GetReference(data));
		}
	}

	public static ref readonly Guid CLSID_D2D1Posterize
	{
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		get
		{
			ReadOnlySpan<byte> data = new byte[] {
				0x5E, 0x94, 0x88, 0x21,
				0xA3, 0x33,
				0x66, 0x43,
				0xB7,
				0xBC,
				0x08,
				0x6B,
				0xD0,
				0x2D,
				0x08,
				0x84
			};

			Debug.Assert(data.Length == Unsafe.SizeOf<Guid>());
			return ref Unsafe.As<byte, Guid>(ref MemoryMarshal.GetReference(data));
		}
	}

	public static ref readonly Guid CLSID_D2D1Sepia
	{
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		get
		{
			ReadOnlySpan<byte> data = new byte[] {
				0x10, 0xF4, 0x1A, 0x3A,
				0x1D, 0x5F,
				0xBE, 0x4D,
				0x84,
				0xDF,
				0x91,
				0x5D,
				0xA7,
				0x9B,
				0x71,
				0x53
			};

			Debug.Assert(data.Length == Unsafe.SizeOf<Guid>());
			return ref Unsafe.As<byte, Guid>(ref MemoryMarshal.GetReference(data));
		}
	}

	public static ref readonly Guid CLSID_D2D1Sharpen
	{
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		get
		{
			ReadOnlySpan<byte> data = new byte[] {
				0xCB, 0x87, 0xB8, 0xC9,
				0xFF, 0xC5,
				0xC5, 0x4D,
				0x97,
				0x79,
				0x27,
				0x3D,
				0xCF,
				0x41,
				0x7C,
				0x7D
			};

			Debug.Assert(data.Length == Unsafe.SizeOf<Guid>());
			return ref Unsafe.As<byte, Guid>(ref MemoryMarshal.GetReference(data));
		}
	}

	public static ref readonly Guid CLSID_D2D1Straighten
	{
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		get
		{
			ReadOnlySpan<byte> data = new byte[] {
				0x12, 0x7B, 0xA4, 0x4D,
				0xA3, 0x79,
				0xB0, 0x4F,
				0x82,
				0x37,
				0xBB,
				0xC3,
				0xB2,
				0xA4,
				0xDE,
				0x08
			};

			Debug.Assert(data.Length == Unsafe.SizeOf<Guid>());
			return ref Unsafe.As<byte, Guid>(ref MemoryMarshal.GetReference(data));
		}
	}

	public static ref readonly Guid CLSID_D2D1TemperatureTint
	{
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		get
		{
			ReadOnlySpan<byte> data = new byte[] {
				0x87, 0x60, 0x17, 0x89,
				0xF9, 0x8A,
				0x08, 0x4A,
				0xAE,
				0xB1,
				0x89,
				0x5F,
				0x38,
				0xDB,
				0x17,
				0x66
			};

			Debug.Assert(data.Length == Unsafe.SizeOf<Guid>());
			return ref Unsafe.As<byte, Guid>(ref MemoryMarshal.GetReference(data));
		}
	}

	public static ref readonly Guid CLSID_D2D1Vignette
	{
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		get
		{
			ReadOnlySpan<byte> data = new byte[] {
				0xBE, 0x40, 0x0C, 0xC0,
				0x67, 0x5E,
				0xA3, 0x4C,
				0x95,
				0xB4,
				0xF4,
				0xB0,
				0x2C,
				0x11,
				0x51,
				0x35
			};

			Debug.Assert(data.Length == Unsafe.SizeOf<Guid>());
			return ref Unsafe.As<byte, Guid>(ref MemoryMarshal.GetReference(data));
		}
	}

	public static ref readonly Guid CLSID_D2D1EdgeDetection
	{
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		get
		{
			ReadOnlySpan<byte> data = new byte[] {
				0xCA, 0x83, 0xF5, 0xEF,
				0x07, 0xCB,
				0xA9, 0x4A,
				0xAC,
				0x5D,
				0x2C,
				0xC4,
				0x4C,
				0x76,
				0x46,
				0x0F
			};

			Debug.Assert(data.Length == Unsafe.SizeOf<Guid>());
			return ref Unsafe.As<byte, Guid>(ref MemoryMarshal.GetReference(data));
		}
	}

	public static ref readonly Guid CLSID_D2D1HighlightsShadows
	{
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		get
		{
			ReadOnlySpan<byte> data = new byte[] {
				0x84, 0x83, 0xDC, 0xCA,
				0x3F, 0x32,
				0x7E, 0x4C,
				0xA3,
				0x61,
				0x2E,
				0x2B,
				0x24,
				0xDF,
				0x6E,
				0xE4
			};

			Debug.Assert(data.Length == Unsafe.SizeOf<Guid>());
			return ref Unsafe.As<byte, Guid>(ref MemoryMarshal.GetReference(data));
		}
	}

	public static ref readonly Guid CLSID_D2D1LookupTable3D
	{
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		get
		{
			ReadOnlySpan<byte> data = new byte[] {
				0xDA, 0x0E, 0x9E, 0x34,
				0x88, 0x00,
				0x79, 0x4A,
				0x9C,
				0xA3,
				0xC7,
				0xE3,
				0x00,
				0x20,
				0x20,
				0x20
			};

			Debug.Assert(data.Length == Unsafe.SizeOf<Guid>());
			return ref Unsafe.As<byte, Guid>(ref MemoryMarshal.GetReference(data));
		}
	}

	public static ref readonly Guid CLSID_D2D1Opacity
	{
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		get
		{
			ReadOnlySpan<byte> data = new byte[] {
				0xA4, 0x79, 0x1D, 0x81,
				0x28, 0xDE,
				0x54, 0x44,
				0x80,
				0x94,
				0xC6,
				0x46,
				0x85,
				0xF8,
				0xBD,
				0x4C
			};

			Debug.Assert(data.Length == Unsafe.SizeOf<Guid>());
			return ref Unsafe.As<byte, Guid>(ref MemoryMarshal.GetReference(data));
		}
	}

	public static ref readonly Guid CLSID_D2D1AlphaMask
	{
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		get
		{
			ReadOnlySpan<byte> data = new byte[] {
				0xF0, 0xCF, 0x0E, 0xC8,
				0xD5, 0x3F,
				0x05, 0x4F,
				0x83,
				0x28,
				0xC5,
				0xD1,
				0x72,
				0x4B,
				0x4F,
				0x0A
			};

			Debug.Assert(data.Length == Unsafe.SizeOf<Guid>());
			return ref Unsafe.As<byte, Guid>(ref MemoryMarshal.GetReference(data));
		}
	}

	public static ref readonly Guid CLSID_D2D1CrossFade
	{
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		get
		{
			ReadOnlySpan<byte> data = new byte[] {
				0xE8, 0x75, 0xF5, 0x12,
				0xB1, 0x4D,
				0x5F, 0x48,
				0x9A,
				0x84,
				0x03,
				0xA0,
				0x7D,
				0xD3,
				0x82,
				0x9F
			};

			Debug.Assert(data.Length == Unsafe.SizeOf<Guid>());
			return ref Unsafe.As<byte, Guid>(ref MemoryMarshal.GetReference(data));
		}
	}

	public static ref readonly Guid CLSID_D2D1Tint
	{
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		get
		{
			ReadOnlySpan<byte> data = new byte[] {
				0x17, 0x2B, 0x31, 0x36,
				0xDD, 0xF7,
				0x14, 0x40,
				0x91,
				0x5D,
				0xFF,
				0xCA,
				0x76,
				0x8C,
				0xF2,
				0x11
			};

			Debug.Assert(data.Length == Unsafe.SizeOf<Guid>());
			return ref Unsafe.As<byte, Guid>(ref MemoryMarshal.GetReference(data));
		}
	}

	public const float D2D1_SCENE_REFERRED_SDR_WHITE_LEVEL = 80f;

	public static ref readonly Guid CLSID_D2D1WhiteLevelAdjustment
	{
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		get
		{
			ReadOnlySpan<byte> data = new byte[] {
				0xDB, 0xCA, 0xA1, 0x44,
				0xDD, 0x6C,
				0x18, 0x48,
				0x8F,
				0xF4,
				0x26,
				0xC1,
				0xCF,
				0xE9,
				0x5B,
				0xDB
			};

			Debug.Assert(data.Length == Unsafe.SizeOf<Guid>());
			return ref Unsafe.As<byte, Guid>(ref MemoryMarshal.GetReference(data));
		}
	}

	public static ref readonly Guid CLSID_D2D1HdrToneMap
	{
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		get
		{
			ReadOnlySpan<byte> data = new byte[] {
				0x8D, 0x74, 0x0B, 0x7B,
				0x10, 0x46,
				0x86, 0x44,
				0xA9,
				0x0C,
				0x99,
				0x9D,
				0x9A,
				0x2E,
				0x2B,
				0x11
			};

			Debug.Assert(data.Length == Unsafe.SizeOf<Guid>());
			return ref Unsafe.As<byte, Guid>(ref MemoryMarshal.GetReference(data));
		}
	}

	public const uint D2D1_APPEND_ALIGNED_ELEMENT = 4294967295;

	public const uint FACILITY_D2D = 2201;

	public const InterpolationModeDefinition D2D1_INTERPOLATION_MODE_DEFINITION_NEAREST_NEIGHBOR = InterpolationModeDefinition.NearestNeighbor;
	public const InterpolationModeDefinition D2D1_INTERPOLATION_MODE_DEFINITION_LINEAR = InterpolationModeDefinition.Linear;
	public const InterpolationModeDefinition D2D1_INTERPOLATION_MODE_DEFINITION_CUBIC = InterpolationModeDefinition.Cubic;
	public const InterpolationModeDefinition D2D1_INTERPOLATION_MODE_DEFINITION_MULTI_SAMPLE_LINEAR = InterpolationModeDefinition.MultiSampleLinear;
	public const InterpolationModeDefinition D2D1_INTERPOLATION_MODE_DEFINITION_ANISOTROPIC = InterpolationModeDefinition.Anisotropic;
	public const InterpolationModeDefinition D2D1_INTERPOLATION_MODE_DEFINITION_HIGH_QUALITY_CUBIC = InterpolationModeDefinition.HighQualityCubic;
	public const InterpolationModeDefinition D2D1_INTERPOLATION_MODE_DEFINITION_FANT = InterpolationModeDefinition.Fant;
	public const InterpolationModeDefinition D2D1_INTERPOLATION_MODE_DEFINITION_MIPMAP_LINEAR = InterpolationModeDefinition.MipmapLinear;
	public const Gamma D2D1_GAMMA_2_2 = Gamma.Gamma_2_2;
	public const Gamma D2D1_GAMMA_1_0 = Gamma.Gamma_1_0;
	public const OpacityMaskContent D2D1_OPACITY_MASK_CONTENT_GRAPHICS = OpacityMaskContent.Graphics;
	public const OpacityMaskContent D2D1_OPACITY_MASK_CONTENT_TEXT_NATURAL = OpacityMaskContent.TextNatural;
	public const OpacityMaskContent D2D1_OPACITY_MASK_CONTENT_TEXT_GDI_COMPATIBLE = OpacityMaskContent.TextGDICompatible;
	public const ExtendMode D2D1_EXTEND_MODE_CLAMP = ExtendMode.Clamp;
	public const ExtendMode D2D1_EXTEND_MODE_WRAP = ExtendMode.Wrap;
	public const ExtendMode D2D1_EXTEND_MODE_MIRROR = ExtendMode.Mirror;
	public const AntialiasMode D2D1_ANTIALIAS_MODE_PER_PRIMITIVE = AntialiasMode.PerPrimitive;
	public const AntialiasMode D2D1_ANTIALIAS_MODE_ALIASED = AntialiasMode.Aliased;
	public const TextAntialiasMode D2D1_TEXT_ANTIALIAS_MODE_DEFAULT = TextAntialiasMode.Default;
	public const TextAntialiasMode D2D1_TEXT_ANTIALIAS_MODE_CLEARTYPE = TextAntialiasMode.Cleartype;
	public const TextAntialiasMode D2D1_TEXT_ANTIALIAS_MODE_GRAYSCALE = TextAntialiasMode.Grayscale;
	public const TextAntialiasMode D2D1_TEXT_ANTIALIAS_MODE_ALIASED = TextAntialiasMode.Aliased;
	public const BitmapInterpolationMode D2D1_BITMAP_INTERPOLATION_MODE_NEAREST_NEIGHBOR = BitmapInterpolationMode.NearestNeighbor;
	public const BitmapInterpolationMode D2D1_BITMAP_INTERPOLATION_MODE_LINEAR = BitmapInterpolationMode.Linear;
	public const DrawTextOptions D2D1_DRAW_TEXT_OPTIONS_NO_SNAP = DrawTextOptions.NoSnap;
	public const DrawTextOptions D2D1_DRAW_TEXT_OPTIONS_CLIP = DrawTextOptions.Clip;
	public const DrawTextOptions D2D1_DRAW_TEXT_OPTIONS_ENABLE_COLOR_FONT = DrawTextOptions.EnableColorFont;
	public const DrawTextOptions D2D1_DRAW_TEXT_OPTIONS_DISABLE_COLOR_BITMAP_SNAPPING = DrawTextOptions.DisableColorBitmapSnapping;
	public const DrawTextOptions D2D1_DRAW_TEXT_OPTIONS_NONE = DrawTextOptions.None;
	public const ArcSize D2D1_ARC_SIZE_SMALL = ArcSize.Small;
	public const ArcSize D2D1_ARC_SIZE_LARGE = ArcSize.Large;
	public const CapStyle D2D1_CAP_STYLE_FLAT = CapStyle.Flat;
	public const CapStyle D2D1_CAP_STYLE_SQUARE = CapStyle.Square;
	public const CapStyle D2D1_CAP_STYLE_ROUND = CapStyle.Round;
	public const CapStyle D2D1_CAP_STYLE_TRIANGLE = CapStyle.Triangle;
	public const DashStyle D2D1_DASH_STYLE_SOLID = DashStyle.Solid;
	public const DashStyle D2D1_DASH_STYLE_DASH = DashStyle.Dash;
	public const DashStyle D2D1_DASH_STYLE_DOT = DashStyle.Dot;
	public const DashStyle D2D1_DASH_STYLE_DASH_DOT = DashStyle.DashDot;
	public const DashStyle D2D1_DASH_STYLE_DASH_DOT_DOT = DashStyle.DashDotDot;
	public const DashStyle D2D1_DASH_STYLE_CUSTOM = DashStyle.Custom;
	public const LineJoin D2D1_LINE_JOIN_MITER = LineJoin.Miter;
	public const LineJoin D2D1_LINE_JOIN_BEVEL = LineJoin.Bevel;
	public const LineJoin D2D1_LINE_JOIN_ROUND = LineJoin.Round;
	public const LineJoin D2D1_LINE_JOIN_MITER_OR_BEVEL = LineJoin.MiterOrBevel;
	public const CombineMode D2D1_COMBINE_MODE_UNION = CombineMode.Union;
	public const CombineMode D2D1_COMBINE_MODE_INTERSECT = CombineMode.Intersect;
	public const CombineMode D2D1_COMBINE_MODE_XOR = CombineMode.Xor;
	public const CombineMode D2D1_COMBINE_MODE_EXCLUDE = CombineMode.Exclude;
	public const GeometryRelation D2D1_GEOMETRY_RELATION_UNKNOWN = GeometryRelation.Unknown;
	public const GeometryRelation D2D1_GEOMETRY_RELATION_DISJOINT = GeometryRelation.Disjoint;
	public const GeometryRelation D2D1_GEOMETRY_RELATION_IS_CONTAINED = GeometryRelation.IsContained;
	public const GeometryRelation D2D1_GEOMETRY_RELATION_CONTAINS = GeometryRelation.Contains;
	public const GeometryRelation D2D1_GEOMETRY_RELATION_OVERLAP = GeometryRelation.Overlap;
	public const GeometrySimplificationOption D2D1_GEOMETRY_SIMPLIFICATION_OPTION_CUBICS_AND_LINES = GeometrySimplificationOption.CubicsAndLines;
	public const GeometrySimplificationOption D2D1_GEOMETRY_SIMPLIFICATION_OPTION_LINES = GeometrySimplificationOption.Lines;
	public const SweepDirection D2D1_SWEEP_DIRECTION_COUNTER_CLOCKWISE = SweepDirection.CounterClockwise;
	public const SweepDirection D2D1_SWEEP_DIRECTION_CLOCKWISE = SweepDirection.Clockwise;
	public const LayerOptions D2D1_LAYER_OPTIONS_NONE = LayerOptions.None;
	public const LayerOptions D2D1_LAYER_OPTIONS_INITIALIZE_FOR_CLEARTYPE = LayerOptions.InitializeForCleartype;
	public const WindowState D2D1_WINDOW_STATE_NONE = WindowState.None;
	public const WindowState D2D1_WINDOW_STATE_OCCLUDED = WindowState.Occluded;
	public const RenderTargetType D2D1_RENDER_TARGET_TYPE_DEFAULT = RenderTargetType.Default;
	public const RenderTargetType D2D1_RENDER_TARGET_TYPE_SOFTWARE = RenderTargetType.Software;
	public const RenderTargetType D2D1_RENDER_TARGET_TYPE_HARDWARE = RenderTargetType.Hardware;
	public const FeatureLevel D2D1_FEATURE_LEVEL_DEFAULT = FeatureLevel.Default;
	public const FeatureLevel D2D1_FEATURE_LEVEL_9 = FeatureLevel.Level_9;
	public const FeatureLevel D2D1_FEATURE_LEVEL_10 = FeatureLevel.Level_10;
	public const RenderTargetUsage D2D1_RENDER_TARGET_USAGE_NONE = RenderTargetUsage.None;
	public const RenderTargetUsage D2D1_RENDER_TARGET_USAGE_FORCE_BITMAP_REMOTING = RenderTargetUsage.ForceBitmapRemoting;
	public const RenderTargetUsage D2D1_RENDER_TARGET_USAGE_GDI_COMPATIBLE = RenderTargetUsage.GDICompatible;
	public const PresentOptions D2D1_PRESENT_OPTIONS_NONE = PresentOptions.None;
	public const PresentOptions D2D1_PRESENT_OPTIONS_RETAIN_CONTENTS = PresentOptions.RetainContents;
	public const PresentOptions D2D1_PRESENT_OPTIONS_IMMEDIATELY = PresentOptions.Immediately;
	public const CompatibleRenderTargetOptions D2D1_COMPATIBLE_RENDER_TARGET_OPTIONS_NONE = CompatibleRenderTargetOptions.None;
	public const CompatibleRenderTargetOptions D2D1_COMPATIBLE_RENDER_TARGET_OPTIONS_GDI_COMPATIBLE = CompatibleRenderTargetOptions.GDICompatible;
	public const DCInitializeMode D2D1_DC_INITIALIZE_MODE_COPY = DCInitializeMode.Copy;
	public const DCInitializeMode D2D1_DC_INITIALIZE_MODE_CLEAR = DCInitializeMode.Clear;
	public const DebugLevel D2D1_DEBUG_LEVEL_NONE = DebugLevel.None;
	public const DebugLevel D2D1_DEBUG_LEVEL_ERROR = DebugLevel.Error;
	public const DebugLevel D2D1_DEBUG_LEVEL_WARNING = DebugLevel.Warning;
	public const DebugLevel D2D1_DEBUG_LEVEL_INFORMATION = DebugLevel.Information;
	public const FactoryType D2D1_FACTORY_TYPE_SINGLE_THREADED = FactoryType.SingleThreaded;
	public const FactoryType D2D1_FACTORY_TYPE_MULTI_THREADED = FactoryType.MultiThreaded;
	public const ChannelSelector D2D1_CHANNEL_SELECTOR_R = ChannelSelector.R;
	public const ChannelSelector D2D1_CHANNEL_SELECTOR_G = ChannelSelector.G;
	public const ChannelSelector D2D1_CHANNEL_SELECTOR_B = ChannelSelector.B;
	public const ChannelSelector D2D1_CHANNEL_SELECTOR_A = ChannelSelector.A;
	public const BitmapSourceOrientation D2D1_BITMAPSOURCE_ORIENTATION_DEFAULT = BitmapSourceOrientation.Default;
	public const BitmapSourceOrientation D2D1_BITMAPSOURCE_ORIENTATION_FLIP_HORIZONTAL = BitmapSourceOrientation.FlipHorizontal;
	public const BitmapSourceOrientation D2D1_BITMAPSOURCE_ORIENTATION_ROTATE_CLOCKWISE180 = BitmapSourceOrientation.RotateClockwise180;
	public const BitmapSourceOrientation D2D1_BITMAPSOURCE_ORIENTATION_ROTATE_CLOCKWISE180_FLIP_HORIZONTAL = BitmapSourceOrientation.RotateClockwise180FlipHorizontal;
	public const BitmapSourceOrientation D2D1_BITMAPSOURCE_ORIENTATION_ROTATE_CLOCKWISE270_FLIP_HORIZONTAL = BitmapSourceOrientation.RotateClockwise270FlipHorizontal;
	public const BitmapSourceOrientation D2D1_BITMAPSOURCE_ORIENTATION_ROTATE_CLOCKWISE90 = BitmapSourceOrientation.RotateClockwise90;
	public const BitmapSourceOrientation D2D1_BITMAPSOURCE_ORIENTATION_ROTATE_CLOCKWISE90_FLIP_HORIZONTAL = BitmapSourceOrientation.RotateClockwise90FlipHorizontal;
	public const BitmapSourceOrientation D2D1_BITMAPSOURCE_ORIENTATION_ROTATE_CLOCKWISE270 = BitmapSourceOrientation.RotateClockwise270;
	public const GaussianBlurProp D2D1_GAUSSIANBLUR_PROP_STANDARD_DEVIATION = GaussianBlurProp.StandardDeviation;
	public const GaussianBlurProp D2D1_GAUSSIANBLUR_PROP_OPTIMIZATION = GaussianBlurProp.Optimization;
	public const GaussianBlurProp D2D1_GAUSSIANBLUR_PROP_BORDER_MODE = GaussianBlurProp.BorderMode;
	public const GaussianBlurOptimization D2D1_GAUSSIANBLUR_OPTIMIZATION_SPEED = GaussianBlurOptimization.Speed;
	public const GaussianBlurOptimization D2D1_GAUSSIANBLUR_OPTIMIZATION_BALANCED = GaussianBlurOptimization.Balanced;
	public const GaussianBlurOptimization D2D1_GAUSSIANBLUR_OPTIMIZATION_QUALITY = GaussianBlurOptimization.Quality;
	public const DirectionalBlurProp D2D1_DIRECTIONALBLUR_PROP_STANDARD_DEVIATION = DirectionalBlurProp.StandardDeviation;
	public const DirectionalBlurProp D2D1_DIRECTIONALBLUR_PROP_ANGLE = DirectionalBlurProp.Angle;
	public const DirectionalBlurProp D2D1_DIRECTIONALBLUR_PROP_OPTIMIZATION = DirectionalBlurProp.Optimization;
	public const DirectionalBlurProp D2D1_DIRECTIONALBLUR_PROP_BORDER_MODE = DirectionalBlurProp.BorderMode;
	public const DirectionalBlurOptimization D2D1_DIRECTIONALBLUR_OPTIMIZATION_SPEED = DirectionalBlurOptimization.Speed;
	public const DirectionalBlurOptimization D2D1_DIRECTIONALBLUR_OPTIMIZATION_BALANCED = DirectionalBlurOptimization.Balanced;
	public const DirectionalBlurOptimization D2D1_DIRECTIONALBLUR_OPTIMIZATION_QUALITY = DirectionalBlurOptimization.Quality;
	public const ShadowProp D2D1_SHADOW_PROP_BLUR_STANDARD_DEVIATION = ShadowProp.BlurStandardDeviation;
	public const ShadowProp D2D1_SHADOW_PROP_COLOR = ShadowProp.Color;
	public const ShadowProp D2D1_SHADOW_PROP_OPTIMIZATION = ShadowProp.Optimization;
	public const ShadowOptimization D2D1_SHADOW_OPTIMIZATION_SPEED = ShadowOptimization.Speed;
	public const ShadowOptimization D2D1_SHADOW_OPTIMIZATION_BALANCED = ShadowOptimization.Balanced;
	public const ShadowOptimization D2D1_SHADOW_OPTIMIZATION_QUALITY = ShadowOptimization.Quality;
	public const BlendProp D2D1_BLEND_PROP_MODE = BlendProp.Mode;
	public const SaturationProp D2D1_SATURATION_PROP_SATURATION = SaturationProp.Saturation;
	public const HueRotationProp D2D1_HUEROTATION_PROP_ANGLE = HueRotationProp.Angle;
	public const ColorMatrixProp D2D1_COLORMATRIX_PROP_COLOR_MATRIX = ColorMatrixProp.ColorMatrix;
	public const ColorMatrixProp D2D1_COLORMATRIX_PROP_ALPHA_MODE = ColorMatrixProp.AlphaMode;
	public const ColorMatrixProp D2D1_COLORMATRIX_PROP_CLAMP_OUTPUT = ColorMatrixProp.ClampOutput;
	public const BitmapSourceProp D2D1_BITMAPSOURCE_PROP_WIC_BITMAP_SOURCE = BitmapSourceProp.WicBitmapSource;
	public const BitmapSourceProp D2D1_BITMAPSOURCE_PROP_SCALE = BitmapSourceProp.Scale;
	public const BitmapSourceProp D2D1_BITMAPSOURCE_PROP_INTERPOLATION_MODE = BitmapSourceProp.InterpolationMode;
	public const BitmapSourceProp D2D1_BITMAPSOURCE_PROP_ENABLE_DPI_CORRECTION = BitmapSourceProp.EnableDpiCorrection;
	public const BitmapSourceProp D2D1_BITMAPSOURCE_PROP_ALPHA_MODE = BitmapSourceProp.AlphaMode;
	public const BitmapSourceProp D2D1_BITMAPSOURCE_PROP_ORIENTATION = BitmapSourceProp.Orientation;
	public const BitmapSourceInterpolationMode D2D1_BITMAPSOURCE_INTERPOLATION_MODE_NEAREST_NEIGHBOR = BitmapSourceInterpolationMode.NearestNeighbor;
	public const BitmapSourceInterpolationMode D2D1_BITMAPSOURCE_INTERPOLATION_MODE_LINEAR = BitmapSourceInterpolationMode.Linear;
	public const BitmapSourceInterpolationMode D2D1_BITMAPSOURCE_INTERPOLATION_MODE_CUBIC = BitmapSourceInterpolationMode.Cubic;
	public const BitmapSourceInterpolationMode D2D1_BITMAPSOURCE_INTERPOLATION_MODE_FANT = BitmapSourceInterpolationMode.Fant;
	public const BitmapSourceInterpolationMode D2D1_BITMAPSOURCE_INTERPOLATION_MODE_MIPMAP_LINEAR = BitmapSourceInterpolationMode.MipmapLinear;
	public const BitmapSourceAlphaMode D2D1_BITMAPSOURCE_ALPHA_MODE_PREMULTIPLIED = BitmapSourceAlphaMode.Premultiplied;
	public const BitmapSourceAlphaMode D2D1_BITMAPSOURCE_ALPHA_MODE_STRAIGHT = BitmapSourceAlphaMode.Straight;
	public const CompositeProp D2D1_COMPOSITE_PROP_MODE = CompositeProp.Mode;
	public const Transform3DProperties D2D1_3DTRANSFORM_PROP_INTERPOLATION_MODE = Transform3DProperties.InterpolationMode;
	public const Transform3DProperties D2D1_3DTRANSFORM_PROP_BORDER_MODE = Transform3DProperties.BorderMode;
	public const Transform3DProperties D2D1_3DTRANSFORM_PROP_TRANSFORM_MATRIX = Transform3DProperties.TransformMatrix;
	public const Transform3DInterpolationMode D2D1_3DTRANSFORM_INTERPOLATION_MODE_NEAREST_NEIGHBOR = Transform3DInterpolationMode.NearestNeighbor;
	public const Transform3DInterpolationMode D2D1_3DTRANSFORM_INTERPOLATION_MODE_LINEAR = Transform3DInterpolationMode.Linear;
	public const Transform3DInterpolationMode D2D1_3DTRANSFORM_INTERPOLATION_MODE_CUBIC = Transform3DInterpolationMode.Cubic;
	public const Transform3DInterpolationMode D2D1_3DTRANSFORM_INTERPOLATION_MODE_MULTI_SAMPLE_LINEAR = Transform3DInterpolationMode.MultiSampleLinear;
	public const Transform3DInterpolationMode D2D1_3DTRANSFORM_INTERPOLATION_MODE_ANISOTROPIC = Transform3DInterpolationMode.Anisotropic;
	public const PerspectiveTransform3DProperties D2D1_3DPERSPECTIVETRANSFORM_PROP_INTERPOLATION_MODE = PerspectiveTransform3DProperties.InterpolationMode;
	public const PerspectiveTransform3DProperties D2D1_3DPERSPECTIVETRANSFORM_PROP_BORDER_MODE = PerspectiveTransform3DProperties.BorderMode;
	public const PerspectiveTransform3DProperties D2D1_3DPERSPECTIVETRANSFORM_PROP_DEPTH = PerspectiveTransform3DProperties.Depth;
	public const PerspectiveTransform3DProperties D2D1_3DPERSPECTIVETRANSFORM_PROP_PERSPECTIVE_ORIGIN = PerspectiveTransform3DProperties.PerspectiveOrigin;
	public const PerspectiveTransform3DProperties D2D1_3DPERSPECTIVETRANSFORM_PROP_LOCAL_OFFSET = PerspectiveTransform3DProperties.LocalOffset;
	public const PerspectiveTransform3DProperties D2D1_3DPERSPECTIVETRANSFORM_PROP_GLOBAL_OFFSET = PerspectiveTransform3DProperties.GlobalOffset;
	public const PerspectiveTransform3DProperties D2D1_3DPERSPECTIVETRANSFORM_PROP_ROTATION_ORIGIN = PerspectiveTransform3DProperties.RotationOrigin;
	public const PerspectiveTransform3DProperties D2D1_3DPERSPECTIVETRANSFORM_PROP_ROTATION = PerspectiveTransform3DProperties.Rotation;
	public const PerspectiveTransform3DInteroplationMode D2D1_3DPERSPECTIVETRANSFORM_INTERPOLATION_MODE_NEAREST_NEIGHBOR = PerspectiveTransform3DInteroplationMode.NearestNeighbor;
	public const PerspectiveTransform3DInteroplationMode D2D1_3DPERSPECTIVETRANSFORM_INTERPOLATION_MODE_LINEAR = PerspectiveTransform3DInteroplationMode.Linear;
	public const PerspectiveTransform3DInteroplationMode D2D1_3DPERSPECTIVETRANSFORM_INTERPOLATION_MODE_CUBIC = PerspectiveTransform3DInteroplationMode.Cubic;
	public const PerspectiveTransform3DInteroplationMode D2D1_3DPERSPECTIVETRANSFORM_INTERPOLATION_MODE_MULTI_SAMPLE_LINEAR = PerspectiveTransform3DInteroplationMode.MultiSampleLinear;
	public const PerspectiveTransform3DInteroplationMode D2D1_3DPERSPECTIVETRANSFORM_INTERPOLATION_MODE_ANISOTROPIC = PerspectiveTransform3DInteroplationMode.Anisotropic;
	public const AffineTransform2DProperties D2D1_2DAFFINETRANSFORM_PROP_INTERPOLATION_MODE = AffineTransform2DProperties.InterpolationMode;
	public const AffineTransform2DProperties D2D1_2DAFFINETRANSFORM_PROP_BORDER_MODE = AffineTransform2DProperties.BorderMode;
	public const AffineTransform2DProperties D2D1_2DAFFINETRANSFORM_PROP_TRANSFORM_MATRIX = AffineTransform2DProperties.TransformMatrix;
	public const AffineTransform2DProperties D2D1_2DAFFINETRANSFORM_PROP_SHARPNESS = AffineTransform2DProperties.Sharpness;
	public const DpiCompensationProp D2D1_DPICOMPENSATION_PROP_INTERPOLATION_MODE = DpiCompensationProp.InterpolationMode;
	public const DpiCompensationProp D2D1_DPICOMPENSATION_PROP_BORDER_MODE = DpiCompensationProp.BorderMode;
	public const DpiCompensationProp D2D1_DPICOMPENSATION_PROP_INPUT_DPI = DpiCompensationProp.InputDpi;
	public const DpiCompensationInterpolationMode D2D1_DPICOMPENSATION_INTERPOLATION_MODE_NEAREST_NEIGHBOR = DpiCompensationInterpolationMode.NearestNeighbor;
	public const DpiCompensationInterpolationMode D2D1_DPICOMPENSATION_INTERPOLATION_MODE_LINEAR = DpiCompensationInterpolationMode.Linear;
	public const DpiCompensationInterpolationMode D2D1_DPICOMPENSATION_INTERPOLATION_MODE_CUBIC = DpiCompensationInterpolationMode.Cubic;
	public const DpiCompensationInterpolationMode D2D1_DPICOMPENSATION_INTERPOLATION_MODE_MULTI_SAMPLE_LINEAR = DpiCompensationInterpolationMode.MultiSampleLinear;
	public const DpiCompensationInterpolationMode D2D1_DPICOMPENSATION_INTERPOLATION_MODE_ANISOTROPIC = DpiCompensationInterpolationMode.Anisotropic;
	public const DpiCompensationInterpolationMode D2D1_DPICOMPENSATION_INTERPOLATION_MODE_HIGH_QUALITY_CUBIC = DpiCompensationInterpolationMode.HighQualityCubic;
	public const ScaleProp D2D1_SCALE_PROP_SCALE = ScaleProp.Scale;
	public const ScaleProp D2D1_SCALE_PROP_CENTER_POINT = ScaleProp.CenterPoint;
	public const ScaleProp D2D1_SCALE_PROP_INTERPOLATION_MODE = ScaleProp.InterpolationMode;
	public const ScaleProp D2D1_SCALE_PROP_BORDER_MODE = ScaleProp.BorderMode;
	public const ScaleProp D2D1_SCALE_PROP_SHARPNESS = ScaleProp.Sharpness;
	public const ScaleInterpolationMode D2D1_SCALE_INTERPOLATION_MODE_NEAREST_NEIGHBOR = ScaleInterpolationMode.NearestNeighbor;
	public const ScaleInterpolationMode D2D1_SCALE_INTERPOLATION_MODE_LINEAR = ScaleInterpolationMode.Linear;
	public const ScaleInterpolationMode D2D1_SCALE_INTERPOLATION_MODE_CUBIC = ScaleInterpolationMode.Cubic;
	public const ScaleInterpolationMode D2D1_SCALE_INTERPOLATION_MODE_MULTI_SAMPLE_LINEAR = ScaleInterpolationMode.MultiSampleLinear;
	public const ScaleInterpolationMode D2D1_SCALE_INTERPOLATION_MODE_ANISOTROPIC = ScaleInterpolationMode.Anisotropic;
	public const ScaleInterpolationMode D2D1_SCALE_INTERPOLATION_MODE_HIGH_QUALITY_CUBIC = ScaleInterpolationMode.HighQualityCubic;
	public const TurbulenceProp D2D1_TURBULENCE_PROP_OFFSET = TurbulenceProp.Offset;
	public const TurbulenceProp D2D1_TURBULENCE_PROP_SIZE = TurbulenceProp.Size;
	public const TurbulenceProp D2D1_TURBULENCE_PROP_BASE_FREQUENCY = TurbulenceProp.BaseFrequency;
	public const TurbulenceProp D2D1_TURBULENCE_PROP_NUM_OCTAVES = TurbulenceProp.NumOctaves;
	public const TurbulenceProp D2D1_TURBULENCE_PROP_SEED = TurbulenceProp.Seed;
	public const TurbulenceProp D2D1_TURBULENCE_PROP_NOISE = TurbulenceProp.Noise;
	public const TurbulenceProp D2D1_TURBULENCE_PROP_STITCHABLE = TurbulenceProp.Stitchable;
	public const DisplacementMapProp D2D1_DISPLACEMENTMAP_PROP_SCALE = DisplacementMapProp.Scale;
	public const DisplacementMapProp D2D1_DISPLACEMENTMAP_PROP_X_CHANNEL_SELECT = DisplacementMapProp.XChannelSelect;
	public const DisplacementMapProp D2D1_DISPLACEMENTMAP_PROP_Y_CHANNEL_SELECT = DisplacementMapProp.YChannelSelect;
	public const ColorManagementProp D2D1_COLORMANAGEMENT_PROP_SOURCE_COLOR_CONTEXT = ColorManagementProp.SourceColorContext;
	public const ColorManagementProp D2D1_COLORMANAGEMENT_PROP_SOURCE_RENDERING_INTENT = ColorManagementProp.SourceRenderingIntent;
	public const ColorManagementProp D2D1_COLORMANAGEMENT_PROP_DESTINATION_COLOR_CONTEXT = ColorManagementProp.DestinationColorContext;
	public const ColorManagementProp D2D1_COLORMANAGEMENT_PROP_DESTINATION_RENDERING_INTENT = ColorManagementProp.DestinationRenderingIntent;
	public const ColorManagementProp D2D1_COLORMANAGEMENT_PROP_ALPHA_MODE = ColorManagementProp.AlphaMode;
	public const ColorManagementProp D2D1_COLORMANAGEMENT_PROP_QUALITY = ColorManagementProp.Quality;
	public const ColorManagementAlphaMode D2D1_COLORMANAGEMENT_ALPHA_MODE_PREMULTIPLIED = ColorManagementAlphaMode.Premultiplied;
	public const ColorManagementAlphaMode D2D1_COLORMANAGEMENT_ALPHA_MODE_STRAIGHT = ColorManagementAlphaMode.Straight;
	public const ColorManagementQuality D2D1_COLORMANAGEMENT_QUALITY_PROOF = ColorManagementQuality.Proof;
	public const ColorManagementQuality D2D1_COLORMANAGEMENT_QUALITY_NORMAL = ColorManagementQuality.Normal;
	public const ColorManagementQuality D2D1_COLORMANAGEMENT_QUALITY_BEST = ColorManagementQuality.Best;
	public const ColorManagementRenderingIntent D2D1_COLORMANAGEMENT_RENDERING_INTENT_PERCEPTUAL = ColorManagementRenderingIntent.Perceptual;
	public const ColorManagementRenderingIntent D2D1_COLORMANAGEMENT_RENDERING_INTENT_RELATIVE_COLORIMETRIC = ColorManagementRenderingIntent.RelativeColorimetric;
	public const ColorManagementRenderingIntent D2D1_COLORMANAGEMENT_RENDERING_INTENT_SATURATION = ColorManagementRenderingIntent.Saturation;
	public const ColorManagementRenderingIntent D2D1_COLORMANAGEMENT_RENDERING_INTENT_ABSOLUTE_COLORIMETRIC = ColorManagementRenderingIntent.AbsoluteColorimetric;
	public const HistogramProp D2D1_HISTOGRAM_PROP_NUM_BINS = HistogramProp.NumBins;
	public const HistogramProp D2D1_HISTOGRAM_PROP_CHANNEL_SELECT = HistogramProp.ChannelSelect;
	public const HistogramProp D2D1_HISTOGRAM_PROP_HISTOGRAM_OUTPUT = HistogramProp.HistogramOutput;
	public const PointSpecularProp D2D1_POINTSPECULAR_PROP_LIGHT_POSITION = PointSpecularProp.LightPosition;
	public const PointSpecularProp D2D1_POINTSPECULAR_PROP_SPECULAR_EXPONENT = PointSpecularProp.SpecularExponent;
	public const PointSpecularProp D2D1_POINTSPECULAR_PROP_SPECULAR_CONSTANT = PointSpecularProp.SpecularConstant;
	public const PointSpecularProp D2D1_POINTSPECULAR_PROP_SURFACE_SCALE = PointSpecularProp.SurfaceScale;
	public const PointSpecularProp D2D1_POINTSPECULAR_PROP_COLOR = PointSpecularProp.Color;
	public const PointSpecularProp D2D1_POINTSPECULAR_PROP_KERNEL_UNIT_LENGTH = PointSpecularProp.KernelUnitLength;
	public const PointSpecularProp D2D1_POINTSPECULAR_PROP_SCALE_MODE = PointSpecularProp.ScaleMode;
	public const PointSpecularScaleMode D2D1_POINTSPECULAR_SCALE_MODE_NEAREST_NEIGHBOR = PointSpecularScaleMode.NearestNeighbor;
	public const PointSpecularScaleMode D2D1_POINTSPECULAR_SCALE_MODE_LINEAR = PointSpecularScaleMode.Linear;
	public const PointSpecularScaleMode D2D1_POINTSPECULAR_SCALE_MODE_CUBIC = PointSpecularScaleMode.Cubic;
	public const PointSpecularScaleMode D2D1_POINTSPECULAR_SCALE_MODE_MULTI_SAMPLE_LINEAR = PointSpecularScaleMode.MultiSampleLinear;
	public const PointSpecularScaleMode D2D1_POINTSPECULAR_SCALE_MODE_ANISOTROPIC = PointSpecularScaleMode.Anisotropic;
	public const PointSpecularScaleMode D2D1_POINTSPECULAR_SCALE_MODE_HIGH_QUALITY_CUBIC = PointSpecularScaleMode.HighQualityCubic;
	public const SpotSpecularProp D2D1_SPOTSPECULAR_PROP_LIGHT_POSITION = SpotSpecularProp.LightPosition;
	public const SpotSpecularProp D2D1_SPOTSPECULAR_PROP_POINTS_AT = SpotSpecularProp.PointsAt;
	public const SpotSpecularProp D2D1_SPOTSPECULAR_PROP_FOCUS = SpotSpecularProp.Focus;
	public const SpotSpecularProp D2D1_SPOTSPECULAR_PROP_LIMITING_CONE_ANGLE = SpotSpecularProp.LimitingConeAngle;
	public const SpotSpecularProp D2D1_SPOTSPECULAR_PROP_SPECULAR_EXPONENT = SpotSpecularProp.SpecularExponent;
	public const SpotSpecularProp D2D1_SPOTSPECULAR_PROP_SPECULAR_CONSTANT = SpotSpecularProp.SpecularConstant;
	public const SpotSpecularProp D2D1_SPOTSPECULAR_PROP_SURFACE_SCALE = SpotSpecularProp.SurfaceScale;
	public const SpotSpecularProp D2D1_SPOTSPECULAR_PROP_COLOR = SpotSpecularProp.Color;
	public const SpotSpecularProp D2D1_SPOTSPECULAR_PROP_KERNEL_UNIT_LENGTH = SpotSpecularProp.KernelUnitLength;
	public const SpotSpecularProp D2D1_SPOTSPECULAR_PROP_SCALE_MODE = SpotSpecularProp.ScaleMode;
	public const SpotSpecularScaleMode D2D1_SPOTSPECULAR_SCALE_MODE_NEAREST_NEIGHBOR = SpotSpecularScaleMode.NearestNeighbor;
	public const SpotSpecularScaleMode D2D1_SPOTSPECULAR_SCALE_MODE_LINEAR = SpotSpecularScaleMode.Linear;
	public const SpotSpecularScaleMode D2D1_SPOTSPECULAR_SCALE_MODE_CUBIC = SpotSpecularScaleMode.Cubic;
	public const SpotSpecularScaleMode D2D1_SPOTSPECULAR_SCALE_MODE_MULTI_SAMPLE_LINEAR = SpotSpecularScaleMode.MultiSampleLinear;
	public const SpotSpecularScaleMode D2D1_SPOTSPECULAR_SCALE_MODE_ANISOTROPIC = SpotSpecularScaleMode.Anisotropic;
	public const SpotSpecularScaleMode D2D1_SPOTSPECULAR_SCALE_MODE_HIGH_QUALITY_CUBIC = SpotSpecularScaleMode.HighQualityCubic;
	public const DistantSpecularProp D2D1_DISTANTSPECULAR_PROP_AZIMUTH = DistantSpecularProp.Azimuth;
	public const DistantSpecularProp D2D1_DISTANTSPECULAR_PROP_ELEVATION = DistantSpecularProp.Elevation;
	public const DistantSpecularProp D2D1_DISTANTSPECULAR_PROP_SPECULAR_EXPONENT = DistantSpecularProp.SpecularExponent;
	public const DistantSpecularProp D2D1_DISTANTSPECULAR_PROP_SPECULAR_CONSTANT = DistantSpecularProp.SpecularConstant;
	public const DistantSpecularProp D2D1_DISTANTSPECULAR_PROP_SURFACE_SCALE = DistantSpecularProp.SurfaceScale;
	public const DistantSpecularProp D2D1_DISTANTSPECULAR_PROP_COLOR = DistantSpecularProp.Color;
	public const DistantSpecularProp D2D1_DISTANTSPECULAR_PROP_KERNEL_UNIT_LENGTH = DistantSpecularProp.KernelUnitLength;
	public const DistantSpecularProp D2D1_DISTANTSPECULAR_PROP_SCALE_MODE = DistantSpecularProp.ScaleMode;
	public const DistantSpecularScaleMode D2D1_DISTANTSPECULAR_SCALE_MODE_NEAREST_NEIGHBOR = DistantSpecularScaleMode.NearestNeighbor;
	public const DistantSpecularScaleMode D2D1_DISTANTSPECULAR_SCALE_MODE_LINEAR = DistantSpecularScaleMode.Linear;
	public const DistantSpecularScaleMode D2D1_DISTANTSPECULAR_SCALE_MODE_CUBIC = DistantSpecularScaleMode.Cubic;
	public const DistantSpecularScaleMode D2D1_DISTANTSPECULAR_SCALE_MODE_MULTI_SAMPLE_LINEAR = DistantSpecularScaleMode.MultiSampleLinear;
	public const DistantSpecularScaleMode D2D1_DISTANTSPECULAR_SCALE_MODE_ANISOTROPIC = DistantSpecularScaleMode.Anisotropic;
	public const DistantSpecularScaleMode D2D1_DISTANTSPECULAR_SCALE_MODE_HIGH_QUALITY_CUBIC = DistantSpecularScaleMode.HighQualityCubic;
	public const PointDiffuseProp D2D1_POINTDIFFUSE_PROP_LIGHT_POSITION = PointDiffuseProp.LightPosition;
	public const PointDiffuseProp D2D1_POINTDIFFUSE_PROP_DIFFUSE_CONSTANT = PointDiffuseProp.DiffuseConstant;
	public const PointDiffuseProp D2D1_POINTDIFFUSE_PROP_SURFACE_SCALE = PointDiffuseProp.SurfaceScale;
	public const PointDiffuseProp D2D1_POINTDIFFUSE_PROP_COLOR = PointDiffuseProp.Color;
	public const PointDiffuseProp D2D1_POINTDIFFUSE_PROP_KERNEL_UNIT_LENGTH = PointDiffuseProp.KernelUnitLength;
	public const PointDiffuseProp D2D1_POINTDIFFUSE_PROP_SCALE_MODE = PointDiffuseProp.ScaleMode;
	public const PointDiffuseScaleMode D2D1_POINTDIFFUSE_SCALE_MODE_NEAREST_NEIGHBOR = PointDiffuseScaleMode.NearestNeighbor;
	public const PointDiffuseScaleMode D2D1_POINTDIFFUSE_SCALE_MODE_LINEAR = PointDiffuseScaleMode.Linear;
	public const PointDiffuseScaleMode D2D1_POINTDIFFUSE_SCALE_MODE_CUBIC = PointDiffuseScaleMode.Cubic;
	public const PointDiffuseScaleMode D2D1_POINTDIFFUSE_SCALE_MODE_MULTI_SAMPLE_LINEAR = PointDiffuseScaleMode.MultiSampleLinear;
	public const PointDiffuseScaleMode D2D1_POINTDIFFUSE_SCALE_MODE_ANISOTROPIC = PointDiffuseScaleMode.Anisotropic;
	public const PointDiffuseScaleMode D2D1_POINTDIFFUSE_SCALE_MODE_HIGH_QUALITY_CUBIC = PointDiffuseScaleMode.HighQualityCubic;
	public const SpotDiffuseProp D2D1_SPOTDIFFUSE_PROP_LIGHT_POSITION = SpotDiffuseProp.LightPosition;
	public const SpotDiffuseProp D2D1_SPOTDIFFUSE_PROP_POINTS_AT = SpotDiffuseProp.PointsAt;
	public const SpotDiffuseProp D2D1_SPOTDIFFUSE_PROP_FOCUS = SpotDiffuseProp.Focus;
	public const SpotDiffuseProp D2D1_SPOTDIFFUSE_PROP_LIMITING_CONE_ANGLE = SpotDiffuseProp.LimitingConeAngle;
	public const SpotDiffuseProp D2D1_SPOTDIFFUSE_PROP_DIFFUSE_CONSTANT = SpotDiffuseProp.DiffuseConstant;
	public const SpotDiffuseProp D2D1_SPOTDIFFUSE_PROP_SURFACE_SCALE = SpotDiffuseProp.SurfaceScale;
	public const SpotDiffuseProp D2D1_SPOTDIFFUSE_PROP_COLOR = SpotDiffuseProp.Color;
	public const SpotDiffuseProp D2D1_SPOTDIFFUSE_PROP_KERNEL_UNIT_LENGTH = SpotDiffuseProp.KernelUnitLength;
	public const SpotDiffuseProp D2D1_SPOTDIFFUSE_PROP_SCALE_MODE = SpotDiffuseProp.ScaleMode;
	public const SpotDiffuseScaleMode D2D1_SPOTDIFFUSE_SCALE_MODE_NEAREST_NEIGHBOR = SpotDiffuseScaleMode.NearestNeighbor;
	public const SpotDiffuseScaleMode D2D1_SPOTDIFFUSE_SCALE_MODE_LINEAR = SpotDiffuseScaleMode.Linear;
	public const SpotDiffuseScaleMode D2D1_SPOTDIFFUSE_SCALE_MODE_CUBIC = SpotDiffuseScaleMode.Cubic;
	public const SpotDiffuseScaleMode D2D1_SPOTDIFFUSE_SCALE_MODE_MULTI_SAMPLE_LINEAR = SpotDiffuseScaleMode.MultiSampleLinear;
	public const SpotDiffuseScaleMode D2D1_SPOTDIFFUSE_SCALE_MODE_ANISOTROPIC = SpotDiffuseScaleMode.Anisotropic;
	public const SpotDiffuseScaleMode D2D1_SPOTDIFFUSE_SCALE_MODE_HIGH_QUALITY_CUBIC = SpotDiffuseScaleMode.HighQualityCubic;
	public const DistantDiffuseProp D2D1_DISTANTDIFFUSE_PROP_AZIMUTH = DistantDiffuseProp.Azimuth;
	public const DistantDiffuseProp D2D1_DISTANTDIFFUSE_PROP_ELEVATION = DistantDiffuseProp.Elevation;
	public const DistantDiffuseProp D2D1_DISTANTDIFFUSE_PROP_DIFFUSE_CONSTANT = DistantDiffuseProp.DiffuseConstant;
	public const DistantDiffuseProp D2D1_DISTANTDIFFUSE_PROP_SURFACE_SCALE = DistantDiffuseProp.SurfaceScale;
	public const DistantDiffuseProp D2D1_DISTANTDIFFUSE_PROP_COLOR = DistantDiffuseProp.Color;
	public const DistantDiffuseProp D2D1_DISTANTDIFFUSE_PROP_KERNEL_UNIT_LENGTH = DistantDiffuseProp.KernelUnitLength;
	public const DistantDiffuseProp D2D1_DISTANTDIFFUSE_PROP_SCALE_MODE = DistantDiffuseProp.ScaleMode;
	public const DistantDiffuseScaleMode D2D1_DISTANTDIFFUSE_SCALE_MODE_NEAREST_NEIGHBOR = DistantDiffuseScaleMode.NearestNeighbor;
	public const DistantDiffuseScaleMode D2D1_DISTANTDIFFUSE_SCALE_MODE_LINEAR = DistantDiffuseScaleMode.Linear;
	public const DistantDiffuseScaleMode D2D1_DISTANTDIFFUSE_SCALE_MODE_CUBIC = DistantDiffuseScaleMode.Cubic;
	public const DistantDiffuseScaleMode D2D1_DISTANTDIFFUSE_SCALE_MODE_MULTI_SAMPLE_LINEAR = DistantDiffuseScaleMode.MultiSampleLinear;
	public const DistantDiffuseScaleMode D2D1_DISTANTDIFFUSE_SCALE_MODE_ANISOTROPIC = DistantDiffuseScaleMode.Anisotropic;
	public const DistantDiffuseScaleMode D2D1_DISTANTDIFFUSE_SCALE_MODE_HIGH_QUALITY_CUBIC = DistantDiffuseScaleMode.HighQualityCubic;
	public const FloodProp D2D1_FLOOD_PROP_COLOR = FloodProp.Color;
	public const LinearTransferProp D2D1_LINEARTRANSFER_PROP_RED_Y_INTERCEPT = LinearTransferProp.RedYIntercept;
	public const LinearTransferProp D2D1_LINEARTRANSFER_PROP_RED_SLOPE = LinearTransferProp.RedSlope;
	public const LinearTransferProp D2D1_LINEARTRANSFER_PROP_RED_DISABLE = LinearTransferProp.RedDisable;
	public const LinearTransferProp D2D1_LINEARTRANSFER_PROP_GREEN_Y_INTERCEPT = LinearTransferProp.GreenYIntercept;
	public const LinearTransferProp D2D1_LINEARTRANSFER_PROP_GREEN_SLOPE = LinearTransferProp.GreenSlope;
	public const LinearTransferProp D2D1_LINEARTRANSFER_PROP_GREEN_DISABLE = LinearTransferProp.GreenDisable;
	public const LinearTransferProp D2D1_LINEARTRANSFER_PROP_BLUE_Y_INTERCEPT = LinearTransferProp.BlueYIntercept;
	public const LinearTransferProp D2D1_LINEARTRANSFER_PROP_BLUE_SLOPE = LinearTransferProp.BlueSlope;
	public const LinearTransferProp D2D1_LINEARTRANSFER_PROP_BLUE_DISABLE = LinearTransferProp.BlueDisable;
	public const LinearTransferProp D2D1_LINEARTRANSFER_PROP_ALPHA_Y_INTERCEPT = LinearTransferProp.AlphaYIntercept;
	public const LinearTransferProp D2D1_LINEARTRANSFER_PROP_ALPHA_SLOPE = LinearTransferProp.AlphaSlope;
	public const LinearTransferProp D2D1_LINEARTRANSFER_PROP_ALPHA_DISABLE = LinearTransferProp.AlphaDisable;
	public const LinearTransferProp D2D1_LINEARTRANSFER_PROP_CLAMP_OUTPUT = LinearTransferProp.ClampOutput;
	public const GammaTransferProp D2D1_GAMMATRANSFER_PROP_RED_AMPLITUDE = GammaTransferProp.RedAmplitude;
	public const GammaTransferProp D2D1_GAMMATRANSFER_PROP_RED_EXPONENT = GammaTransferProp.RedExponent;
	public const GammaTransferProp D2D1_GAMMATRANSFER_PROP_RED_OFFSET = GammaTransferProp.RedOffset;
	public const GammaTransferProp D2D1_GAMMATRANSFER_PROP_RED_DISABLE = GammaTransferProp.RedDisable;
	public const GammaTransferProp D2D1_GAMMATRANSFER_PROP_GREEN_AMPLITUDE = GammaTransferProp.GreenAmplitude;
	public const GammaTransferProp D2D1_GAMMATRANSFER_PROP_GREEN_EXPONENT = GammaTransferProp.GreenExponent;
	public const GammaTransferProp D2D1_GAMMATRANSFER_PROP_GREEN_OFFSET = GammaTransferProp.GreenOffset;
	public const GammaTransferProp D2D1_GAMMATRANSFER_PROP_GREEN_DISABLE = GammaTransferProp.GreenDisable;
	public const GammaTransferProp D2D1_GAMMATRANSFER_PROP_BLUE_AMPLITUDE = GammaTransferProp.BlueAmplitude;
	public const GammaTransferProp D2D1_GAMMATRANSFER_PROP_BLUE_EXPONENT = GammaTransferProp.BlueExponent;
	public const GammaTransferProp D2D1_GAMMATRANSFER_PROP_BLUE_OFFSET = GammaTransferProp.BlueOffset;
	public const GammaTransferProp D2D1_GAMMATRANSFER_PROP_BLUE_DISABLE = GammaTransferProp.BlueDisable;
	public const GammaTransferProp D2D1_GAMMATRANSFER_PROP_ALPHA_AMPLITUDE = GammaTransferProp.AlphaAmplitude;
	public const GammaTransferProp D2D1_GAMMATRANSFER_PROP_ALPHA_EXPONENT = GammaTransferProp.AlphaExponent;
	public const GammaTransferProp D2D1_GAMMATRANSFER_PROP_ALPHA_OFFSET = GammaTransferProp.AlphaOffset;
	public const GammaTransferProp D2D1_GAMMATRANSFER_PROP_ALPHA_DISABLE = GammaTransferProp.AlphaDisable;
	public const GammaTransferProp D2D1_GAMMATRANSFER_PROP_CLAMP_OUTPUT = GammaTransferProp.ClampOutput;
	public const TableTransferProp D2D1_TABLETRANSFER_PROP_RED_TABLE = TableTransferProp.RedTable;
	public const TableTransferProp D2D1_TABLETRANSFER_PROP_RED_DISABLE = TableTransferProp.RedDisable;
	public const TableTransferProp D2D1_TABLETRANSFER_PROP_GREEN_TABLE = TableTransferProp.GreenTable;
	public const TableTransferProp D2D1_TABLETRANSFER_PROP_GREEN_DISABLE = TableTransferProp.GreenDisable;
	public const TableTransferProp D2D1_TABLETRANSFER_PROP_BLUE_TABLE = TableTransferProp.BlueTable;
	public const TableTransferProp D2D1_TABLETRANSFER_PROP_BLUE_DISABLE = TableTransferProp.BlueDisable;
	public const TableTransferProp D2D1_TABLETRANSFER_PROP_ALPHA_TABLE = TableTransferProp.AlphaTable;
	public const TableTransferProp D2D1_TABLETRANSFER_PROP_ALPHA_DISABLE = TableTransferProp.AlphaDisable;
	public const TableTransferProp D2D1_TABLETRANSFER_PROP_CLAMP_OUTPUT = TableTransferProp.ClampOutput;
	public const DiscreteTransferProp D2D1_DISCRETETRANSFER_PROP_RED_TABLE = DiscreteTransferProp.RedTable;
	public const DiscreteTransferProp D2D1_DISCRETETRANSFER_PROP_RED_DISABLE = DiscreteTransferProp.RedDisable;
	public const DiscreteTransferProp D2D1_DISCRETETRANSFER_PROP_GREEN_TABLE = DiscreteTransferProp.GreenTable;
	public const DiscreteTransferProp D2D1_DISCRETETRANSFER_PROP_GREEN_DISABLE = DiscreteTransferProp.GreenDisable;
	public const DiscreteTransferProp D2D1_DISCRETETRANSFER_PROP_BLUE_TABLE = DiscreteTransferProp.BlueTable;
	public const DiscreteTransferProp D2D1_DISCRETETRANSFER_PROP_BLUE_DISABLE = DiscreteTransferProp.BlueDisable;
	public const DiscreteTransferProp D2D1_DISCRETETRANSFER_PROP_ALPHA_TABLE = DiscreteTransferProp.AlphaTable;
	public const DiscreteTransferProp D2D1_DISCRETETRANSFER_PROP_ALPHA_DISABLE = DiscreteTransferProp.AlphaDisable;
	public const DiscreteTransferProp D2D1_DISCRETETRANSFER_PROP_CLAMP_OUTPUT = DiscreteTransferProp.ClampOutput;
	public const ConvolveMatrixProp D2D1_CONVOLVEMATRIX_PROP_KERNEL_UNIT_LENGTH = ConvolveMatrixProp.KernelUnitLength;
	public const ConvolveMatrixProp D2D1_CONVOLVEMATRIX_PROP_SCALE_MODE = ConvolveMatrixProp.ScaleMode;
	public const ConvolveMatrixProp D2D1_CONVOLVEMATRIX_PROP_KERNEL_SIZE_X = ConvolveMatrixProp.KernelSizeX;
	public const ConvolveMatrixProp D2D1_CONVOLVEMATRIX_PROP_KERNEL_SIZE_Y = ConvolveMatrixProp.KernelSizeY;
	public const ConvolveMatrixProp D2D1_CONVOLVEMATRIX_PROP_KERNEL_MATRIX = ConvolveMatrixProp.KernelMatrix;
	public const ConvolveMatrixProp D2D1_CONVOLVEMATRIX_PROP_DIVISOR = ConvolveMatrixProp.Divisor;
	public const ConvolveMatrixProp D2D1_CONVOLVEMATRIX_PROP_BIAS = ConvolveMatrixProp.Bias;
	public const ConvolveMatrixProp D2D1_CONVOLVEMATRIX_PROP_KERNEL_OFFSET = ConvolveMatrixProp.KernelOffset;
	public const ConvolveMatrixProp D2D1_CONVOLVEMATRIX_PROP_PRESERVE_ALPHA = ConvolveMatrixProp.PreserveAlpha;
	public const ConvolveMatrixProp D2D1_CONVOLVEMATRIX_PROP_BORDER_MODE = ConvolveMatrixProp.BorderMode;
	public const ConvolveMatrixProp D2D1_CONVOLVEMATRIX_PROP_CLAMP_OUTPUT = ConvolveMatrixProp.ClampOutput;
	public const ConvolveMatrixScaleMode D2D1_CONVOLVEMATRIX_SCALE_MODE_NEAREST_NEIGHBOR = ConvolveMatrixScaleMode.NearestNeighbor;
	public const ConvolveMatrixScaleMode D2D1_CONVOLVEMATRIX_SCALE_MODE_LINEAR = ConvolveMatrixScaleMode.Linear;
	public const ConvolveMatrixScaleMode D2D1_CONVOLVEMATRIX_SCALE_MODE_CUBIC = ConvolveMatrixScaleMode.Cubic;
	public const ConvolveMatrixScaleMode D2D1_CONVOLVEMATRIX_SCALE_MODE_MULTI_SAMPLE_LINEAR = ConvolveMatrixScaleMode.MultiSampleLinear;
	public const ConvolveMatrixScaleMode D2D1_CONVOLVEMATRIX_SCALE_MODE_ANISOTROPIC = ConvolveMatrixScaleMode.Anisotropic;
	public const ConvolveMatrixScaleMode D2D1_CONVOLVEMATRIX_SCALE_MODE_HIGH_QUALITY_CUBIC = ConvolveMatrixScaleMode.HighQualityCubic;
	public const BrightnessProp D2D1_BRIGHTNESS_PROP_WHITE_POINT = BrightnessProp.WhitePoint;
	public const BrightnessProp D2D1_BRIGHTNESS_PROP_BLACK_POINT = BrightnessProp.BlackPoint;
	public const ArithmeticCompositeProp D2D1_ARITHMETICCOMPOSITE_PROP_COEFFICIENTS = ArithmeticCompositeProp.Coefficients;
	public const ArithmeticCompositeProp D2D1_ARITHMETICCOMPOSITE_PROP_CLAMP_OUTPUT = ArithmeticCompositeProp.ClampOutput;
	public const CropProp D2D1_CROP_PROP_RECT = CropProp.Rect;
	public const CropProp D2D1_CROP_PROP_BORDER_MODE = CropProp.BorderMode;
	public const BorderProp D2D1_BORDER_PROP_EDGE_MODE_X = BorderProp.EdgeModeX;
	public const BorderProp D2D1_BORDER_PROP_EDGE_MODE_Y = BorderProp.EdgeModeY;
	public const BorderEdgeMode D2D1_BORDER_EDGE_MODE_CLAMP = BorderEdgeMode.Clamp;
	public const BorderEdgeMode D2D1_BORDER_EDGE_MODE_WRAP = BorderEdgeMode.Wrap;
	public const BorderEdgeMode D2D1_BORDER_EDGE_MODE_MIRROR = BorderEdgeMode.Mirror;
	public const MorphologyProp D2D1_MORPHOLOGY_PROP_MODE = MorphologyProp.Mode;
	public const MorphologyProp D2D1_MORPHOLOGY_PROP_WIDTH = MorphologyProp.Width;
	public const MorphologyProp D2D1_MORPHOLOGY_PROP_HEIGHT = MorphologyProp.Height;
	public const MorphologyMode D2D1_MORPHOLOGY_MODE_ERODE = MorphologyMode.Erode;
	public const MorphologyMode D2D1_MORPHOLOGY_MODE_DILATE = MorphologyMode.Dilate;
	public const TileProp D2D1_TILE_PROP_RECT = TileProp.Rect;
	public const AtlasProp D2D1_ATLAS_PROP_INPUT_RECT = AtlasProp.InputRect;
	public const AtlasProp D2D1_ATLAS_PROP_INPUT_PADDING_RECT = AtlasProp.InputPaddingRect;
	public const OpacityMetadataProp D2D1_OPACITYMETADATA_PROP_INPUT_OPAQUE_RECT = OpacityMetadataProp.InputOpaqueRect;
	public const PropertyType D2D1_PROPERTY_TYPE_UNKNOWN = PropertyType.Unknown;
	public const PropertyType D2D1_PROPERTY_TYPE_STRING = PropertyType.String;
	public const PropertyType D2D1_PROPERTY_TYPE_BOOL = PropertyType.Bool;
	public const PropertyType D2D1_PROPERTY_TYPE_UINT32 = PropertyType.UInt32;
	public const PropertyType D2D1_PROPERTY_TYPE_INT32 = PropertyType.Int32;
	public const PropertyType D2D1_PROPERTY_TYPE_FLOAT = PropertyType.Float;
	public const PropertyType D2D1_PROPERTY_TYPE_VECTOR2 = PropertyType.Vector2;
	public const PropertyType D2D1_PROPERTY_TYPE_VECTOR3 = PropertyType.Vector3;
	public const PropertyType D2D1_PROPERTY_TYPE_VECTOR4 = PropertyType.Vector4;
	public const PropertyType D2D1_PROPERTY_TYPE_BLOB = PropertyType.Blob;
	public const PropertyType D2D1_PROPERTY_TYPE_IUNKNOWN = PropertyType.IUnknown;
	public const PropertyType D2D1_PROPERTY_TYPE_ENUM = PropertyType.Enum;
	public const PropertyType D2D1_PROPERTY_TYPE_ARRAY = PropertyType.Array;
	public const PropertyType D2D1_PROPERTY_TYPE_CLSID = PropertyType.Clsid;
	public const PropertyType D2D1_PROPERTY_TYPE_MATRIX_3X2 = PropertyType.Matrix3x2;
	public const PropertyType D2D1_PROPERTY_TYPE_MATRIX_4X3 = PropertyType.Matrix4x3;
	public const PropertyType D2D1_PROPERTY_TYPE_MATRIX_4X4 = PropertyType.Matrix4x4;
	public const PropertyType D2D1_PROPERTY_TYPE_MATRIX_5X4 = PropertyType.Matrix5x4;
	public const PropertyType D2D1_PROPERTY_TYPE_COLOR_CONTEXT = PropertyType.ColorContext;
	public const Property D2D1_PROPERTY_CLSID = Property.Clsid;
	public const Property D2D1_PROPERTY_DISPLAYNAME = Property.Displayname;
	public const Property D2D1_PROPERTY_AUTHOR = Property.Author;
	public const Property D2D1_PROPERTY_CATEGORY = Property.Category;
	public const Property D2D1_PROPERTY_DESCRIPTION = Property.Description;
	public const Property D2D1_PROPERTY_INPUTS = Property.Inputs;
	public const Property D2D1_PROPERTY_CACHED = Property.Cached;
	public const Property D2D1_PROPERTY_PRECISION = Property.Precision;
	public const Property D2D1_PROPERTY_MIN_INPUTS = Property.MinInputs;
	public const Property D2D1_PROPERTY_MAX_INPUTS = Property.MaxInputs;
	public const SubProperty D2D1_SUBPROPERTY_DISPLAYNAME = SubProperty.Displayname;
	public const SubProperty D2D1_SUBPROPERTY_ISREADONLY = SubProperty.Isreadonly;
	public const SubProperty D2D1_SUBPROPERTY_MIN = SubProperty.Min;
	public const SubProperty D2D1_SUBPROPERTY_MAX = SubProperty.Max;
	public const SubProperty D2D1_SUBPROPERTY_DEFAULT = SubProperty.Default;
	public const SubProperty D2D1_SUBPROPERTY_FIELDS = SubProperty.Fields;
	public const SubProperty D2D1_SUBPROPERTY_INDEX = SubProperty.Index;
	public const BitmapOptions D2D1_BITMAP_OPTIONS_NONE = BitmapOptions.None;
	public const BitmapOptions D2D1_BITMAP_OPTIONS_TARGET = BitmapOptions.Target;
	public const BitmapOptions D2D1_BITMAP_OPTIONS_CANNOT_DRAW = BitmapOptions.CannotDraw;
	public const BitmapOptions D2D1_BITMAP_OPTIONS_CPU_READ = BitmapOptions.CpuRead;
	public const BitmapOptions D2D1_BITMAP_OPTIONS_GDI_COMPATIBLE = BitmapOptions.GDICompatible;
	public const BufferPrecision D2D1_BUFFER_PRECISION_UNKNOWN = BufferPrecision.Unknown;
	public const BufferPrecision D2D1_BUFFER_PRECISION_8BPC_UNORM = BufferPrecision.Precision8BitUnorm;
	public const BufferPrecision D2D1_BUFFER_PRECISION_8BPC_UNORM_SRGB = BufferPrecision.Precision8BitUnormSrgb;
	public const BufferPrecision D2D1_BUFFER_PRECISION_16BPC_UNORM = BufferPrecision.Precision16BitUnorm;
	public const BufferPrecision D2D1_BUFFER_PRECISION_16BPC_FLOAT = BufferPrecision.Precision16BitFloat;
	public const BufferPrecision D2D1_BUFFER_PRECISION_32BPC_FLOAT = BufferPrecision.Precision32BitFloat;
	public const MapOptions D2D1_MAP_OPTIONS_NONE = MapOptions.None;
	public const MapOptions D2D1_MAP_OPTIONS_READ = MapOptions.Read;
	public const MapOptions D2D1_MAP_OPTIONS_WRITE = MapOptions.Write;
	public const MapOptions D2D1_MAP_OPTIONS_DISCARD = MapOptions.Discard;
	public const InterpolationMode D2D1_INTERPOLATION_MODE_NEAREST_NEIGHBOR = InterpolationMode.NearestNeighbor;
	public const InterpolationMode D2D1_INTERPOLATION_MODE_LINEAR = InterpolationMode.Linear;
	public const InterpolationMode D2D1_INTERPOLATION_MODE_CUBIC = InterpolationMode.Cubic;
	public const InterpolationMode D2D1_INTERPOLATION_MODE_MULTI_SAMPLE_LINEAR = InterpolationMode.MultiSampleLinear;
	public const InterpolationMode D2D1_INTERPOLATION_MODE_ANISOTROPIC = InterpolationMode.Anisotropic;
	public const InterpolationMode D2D1_INTERPOLATION_MODE_HIGH_QUALITY_CUBIC = InterpolationMode.HighQualityCubic;
	public const UnitMode D2D1_UNIT_MODE_DIPS = UnitMode.Dips;
	public const UnitMode D2D1_UNIT_MODE_PIXELS = UnitMode.Pixels;
	public const ColorSpace D2D1_COLOR_SPACE_CUSTOM = ColorSpace.Custom;
	public const ColorSpace D2D1_COLOR_SPACE_SRGB = ColorSpace.Srgb;
	public const ColorSpace D2D1_COLOR_SPACE_SCRGB = ColorSpace.Scrgb;
	public const DeviceContextOptions D2D1_DEVICE_CONTEXT_OPTIONS_NONE = DeviceContextOptions.None;
	public const DeviceContextOptions D2D1_DEVICE_CONTEXT_OPTIONS_ENABLE_MULTITHREADED_OPTIMIZATIONS = DeviceContextOptions.EnableMultithreadedOptimizations;
	public const StrokeTransformType D2D1_STROKE_TRANSFORM_TYPE_NORMAL = StrokeTransformType.Normal;
	public const StrokeTransformType D2D1_STROKE_TRANSFORM_TYPE_FIXED = StrokeTransformType.Fixed;
	public const StrokeTransformType D2D1_STROKE_TRANSFORM_TYPE_HAIRLINE = StrokeTransformType.Hairline;
	public const PrimitiveBlend D2D1_PRIMITIVE_BLEND_SOURCE_OVER = PrimitiveBlend.SourceOver;
	public const PrimitiveBlend D2D1_PRIMITIVE_BLEND_COPY = PrimitiveBlend.Copy;
	public const PrimitiveBlend D2D1_PRIMITIVE_BLEND_MIN = PrimitiveBlend.Min;
	public const PrimitiveBlend D2D1_PRIMITIVE_BLEND_ADD = PrimitiveBlend.Add;
	public const PrimitiveBlend D2D1_PRIMITIVE_BLEND_MAX = PrimitiveBlend.Max;
	public const ThreadingMode D2D1_THREADING_MODE_SINGLE_THREADED = ThreadingMode.SingleThreaded;
	public const ThreadingMode D2D1_THREADING_MODE_MULTI_THREADED = ThreadingMode.MultiThreaded;
	public const ColorInterpolationMode D2D1_COLOR_INTERPOLATION_MODE_STRAIGHT = ColorInterpolationMode.Straight;
	public const ColorInterpolationMode D2D1_COLOR_INTERPOLATION_MODE_PREMULTIPLIED = ColorInterpolationMode.Premultiplied;
	public const LayerOptions1 D2D1_LAYER_OPTIONS1_NONE = LayerOptions1.None;
	public const LayerOptions1 D2D1_LAYER_OPTIONS1_INITIALIZE_FROM_BACKGROUND = LayerOptions1.InitializeFromBackground;
	public const LayerOptions1 D2D1_LAYER_OPTIONS1_IGNORE_ALPHA = LayerOptions1.IgnoreAlpha;
	public const PrintFontSubsetMode D2D1_PRINT_FONT_SUBSET_MODE_DEFAULT = PrintFontSubsetMode.Default;
	public const PrintFontSubsetMode D2D1_PRINT_FONT_SUBSET_MODE_EACHPAGE = PrintFontSubsetMode.Eachpage;
	public const PrintFontSubsetMode D2D1_PRINT_FONT_SUBSET_MODE_NONE = PrintFontSubsetMode.None;
	public const ChangeType D2D1_CHANGE_TYPE_NONE = ChangeType.None;
	public const ChangeType D2D1_CHANGE_TYPE_PROPERTIES = ChangeType.Properties;
	public const ChangeType D2D1_CHANGE_TYPE_CONTEXT = ChangeType.Context;
	public const ChangeType D2D1_CHANGE_TYPE_GRAPH = ChangeType.Graph;
	public const PixelOptions D2D1_PIXEL_OPTIONS_NONE = PixelOptions.None;
	public const PixelOptions D2D1_PIXEL_OPTIONS_TRIVIAL_SAMPLING = PixelOptions.TrivialSampling;
	public const VertexOptions D2D1_VERTEX_OPTIONS_NONE = VertexOptions.None;
	public const VertexOptions D2D1_VERTEX_OPTIONS_DO_NOT_CLEAR = VertexOptions.DoNotClear;
	public const VertexOptions D2D1_VERTEX_OPTIONS_USE_DEPTH_BUFFER = VertexOptions.UseDepthBuffer;
	public const VertexOptions D2D1_VERTEX_OPTIONS_ASSUME_NO_OVERLAP = VertexOptions.AssumeNoOverlap;
	public const VertexUsage D2D1_VERTEX_USAGE_STATIC = VertexUsage.Static;
	public const VertexUsage D2D1_VERTEX_USAGE_DYNAMIC = VertexUsage.Dynamic;
	public const BlendOperation D2D1_BLEND_OPERATION_ADD = BlendOperation.Add;
	public const BlendOperation D2D1_BLEND_OPERATION_SUBTRACT = BlendOperation.Subtract;
	public const BlendOperation D2D1_BLEND_OPERATION_REV_SUBTRACT = BlendOperation.ReverseSubtract;
	public const BlendOperation D2D1_BLEND_OPERATION_MIN = BlendOperation.Min;
	public const BlendOperation D2D1_BLEND_OPERATION_MAX = BlendOperation.Max;
	public const Blend D2D1_BLEND_ZERO = Blend.Zero;
	public const Blend D2D1_BLEND_ONE = Blend.One;
	public const Blend D2D1_BLEND_SRC_COLOR = Blend.SrcColor;
	public const Blend D2D1_BLEND_INV_SRC_COLOR = Blend.InverseSrcColor;
	public const Blend D2D1_BLEND_SRC_ALPHA = Blend.SrcAlpha;
	public const Blend D2D1_BLEND_INV_SRC_ALPHA = Blend.InverseSrcAlpha;
	public const Blend D2D1_BLEND_DEST_ALPHA = Blend.DestAlpha;
	public const Blend D2D1_BLEND_INV_DEST_ALPHA = Blend.InverseDestAlpha;
	public const Blend D2D1_BLEND_DEST_COLOR = Blend.DestColor;
	public const Blend D2D1_BLEND_INV_DEST_COLOR = Blend.InverseDestColor;
	public const Blend D2D1_BLEND_SRC_ALPHA_SAT = Blend.SrcAlphaSaturate;
	public const Blend D2D1_BLEND_BLEND_FACTOR = Blend.BlendFactor;
	public const Blend D2D1_BLEND_INV_BLEND_FACTOR = Blend.InverseBlendFactor;
	public const ChannelDepth D2D1_CHANNEL_DEPTH_DEFAULT = ChannelDepth.Default;
	public const ChannelDepth D2D1_CHANNEL_DEPTH_1 = ChannelDepth._1;
	public const ChannelDepth D2D1_CHANNEL_DEPTH_4 = ChannelDepth._4;
	public const Filter D2D1_FILTER_MIN_MAG_MIP_POINT = Filter.MinMagMipPoint;
	public const Filter D2D1_FILTER_MIN_MAG_POINT_MIP_LINEAR = Filter.MinMagPointMipLinear;
	public const Filter D2D1_FILTER_MIN_POINT_MAG_LINEAR_MIP_POINT = Filter.MinPointMagLinearMipPoint;
	public const Filter D2D1_FILTER_MIN_POINT_MAG_MIP_LINEAR = Filter.MinPointMagMipLinear;
	public const Filter D2D1_FILTER_MIN_LINEAR_MAG_MIP_POINT = Filter.MinLinearMagMipPoint;
	public const Filter D2D1_FILTER_MIN_LINEAR_MAG_POINT_MIP_LINEAR = Filter.MinLinearMagPointMipLinear;
	public const Filter D2D1_FILTER_MIN_MAG_LINEAR_MIP_POINT = Filter.MinMagLinearMipPoint;
	public const Filter D2D1_FILTER_MIN_MAG_MIP_LINEAR = Filter.MinMagMipLinear;
	public const Filter D2D1_FILTER_ANISOTROPIC = Filter.Anisotropic;
	public const Feature D2D1_FEATURE_DOUBLES = Feature.Doubles;
	public const Feature D2D1_FEATURE_D3D10_X_HARDWARE_OPTIONS = Feature.XHardwareOptions;
	public const YcbcrProp D2D1_YCBCR_PROP_CHROMA_SUBSAMPLING = YcbcrProp.ChromaSubsampling;
	public const YcbcrProp D2D1_YCBCR_PROP_TRANSFORM_MATRIX = YcbcrProp.TransformMatrix;
	public const YcbcrProp D2D1_YCBCR_PROP_INTERPOLATION_MODE = YcbcrProp.InterpolationMode;
	public const YcbcrChromaSubsampling D2D1_YCBCR_CHROMA_SUBSAMPLING_AUTO = YcbcrChromaSubsampling.Auto;
	public const YcbcrChromaSubsampling D2D1_YCBCR_CHROMA_SUBSAMPLING_420 = YcbcrChromaSubsampling._420;
	public const YcbcrChromaSubsampling D2D1_YCBCR_CHROMA_SUBSAMPLING_422 = YcbcrChromaSubsampling._422;
	public const YcbcrChromaSubsampling D2D1_YCBCR_CHROMA_SUBSAMPLING_444 = YcbcrChromaSubsampling._444;
	public const YcbcrChromaSubsampling D2D1_YCBCR_CHROMA_SUBSAMPLING_440 = YcbcrChromaSubsampling._440;
	public const YcbcrInterpolationMode D2D1_YCBCR_INTERPOLATION_MODE_NEAREST_NEIGHBOR = YcbcrInterpolationMode.NearestNeighbor;
	public const YcbcrInterpolationMode D2D1_YCBCR_INTERPOLATION_MODE_LINEAR = YcbcrInterpolationMode.Linear;
	public const YcbcrInterpolationMode D2D1_YCBCR_INTERPOLATION_MODE_CUBIC = YcbcrInterpolationMode.Cubic;
	public const YcbcrInterpolationMode D2D1_YCBCR_INTERPOLATION_MODE_MULTI_SAMPLE_LINEAR = YcbcrInterpolationMode.MultiSampleLinear;
	public const YcbcrInterpolationMode D2D1_YCBCR_INTERPOLATION_MODE_ANISOTROPIC = YcbcrInterpolationMode.Anisotropic;
	public const YcbcrInterpolationMode D2D1_YCBCR_INTERPOLATION_MODE_HIGH_QUALITY_CUBIC = YcbcrInterpolationMode.HighQualityCubic;
	public const ContrastProp D2D1_CONTRAST_PROP_CONTRAST = ContrastProp.Contrast;
	public const ContrastProp D2D1_CONTRAST_PROP_CLAMP_INPUT = ContrastProp.ClampInput;
	public const RgbToHueProp D2D1_RGBTOHUE_PROP_OUTPUT_COLOR_SPACE = RgbToHueProp.OutputColorSpace;
	public const RgbToHueOutputColorSpace D2D1_RGBTOHUE_OUTPUT_COLOR_SPACE_HUE_SATURATION_VALUE = RgbToHueOutputColorSpace.HueSaturationValue;
	public const RgbToHueOutputColorSpace D2D1_RGBTOHUE_OUTPUT_COLOR_SPACE_HUE_SATURATION_LIGHTNESS = RgbToHueOutputColorSpace.HueSaturationLightness;
	public const HueToRgbProp D2D1_HUETORGB_PROP_INPUT_COLOR_SPACE = HueToRgbProp.InputColorSpace;
	public const HueToRgbInputColorSpace D2D1_HUETORGB_INPUT_COLOR_SPACE_HUE_SATURATION_VALUE = HueToRgbInputColorSpace.HueSaturationValue;
	public const HueToRgbInputColorSpace D2D1_HUETORGB_INPUT_COLOR_SPACE_HUE_SATURATION_LIGHTNESS = HueToRgbInputColorSpace.HueSaturationLightness;
	public const ChromaKeyProp D2D1_CHROMAKEY_PROP_COLOR = ChromaKeyProp.Color;
	public const ChromaKeyProp D2D1_CHROMAKEY_PROP_TOLERANCE = ChromaKeyProp.Tolerance;
	public const ChromaKeyProp D2D1_CHROMAKEY_PROP_INVERT_ALPHA = ChromaKeyProp.InvertAlpha;
	public const ChromaKeyProp D2D1_CHROMAKEY_PROP_FEATHER = ChromaKeyProp.Feather;
	public const EmbossProp D2D1_EMBOSS_PROP_HEIGHT = EmbossProp.Height;
	public const EmbossProp D2D1_EMBOSS_PROP_DIRECTION = EmbossProp.Direction;
	public const ExposureProp D2D1_EXPOSURE_PROP_EXPOSURE_VALUE = ExposureProp.ExposureValue;
	public const PosterizeProp D2D1_POSTERIZE_PROP_RED_VALUE_COUNT = PosterizeProp.RedValueCount;
	public const PosterizeProp D2D1_POSTERIZE_PROP_GREEN_VALUE_COUNT = PosterizeProp.GreenValueCount;
	public const PosterizeProp D2D1_POSTERIZE_PROP_BLUE_VALUE_COUNT = PosterizeProp.BlueValueCount;
	public const SepiaProp D2D1_SEPIA_PROP_INTENSITY = SepiaProp.Intensity;
	public const SepiaProp D2D1_SEPIA_PROP_ALPHA_MODE = SepiaProp.AlphaMode;
	public const SharpenProp D2D1_SHARPEN_PROP_SHARPNESS = SharpenProp.Sharpness;
	public const SharpenProp D2D1_SHARPEN_PROP_THRESHOLD = SharpenProp.Threshold;
	public const StraightenProp D2D1_STRAIGHTEN_PROP_ANGLE = StraightenProp.Angle;
	public const StraightenProp D2D1_STRAIGHTEN_PROP_MAINTAIN_SIZE = StraightenProp.MaintainSize;
	public const StraightenProp D2D1_STRAIGHTEN_PROP_SCALE_MODE = StraightenProp.ScaleMode;
	public const StraightenScaleMode D2D1_STRAIGHTEN_SCALE_MODE_NEAREST_NEIGHBOR = StraightenScaleMode.NearestNeighbor;
	public const StraightenScaleMode D2D1_STRAIGHTEN_SCALE_MODE_LINEAR = StraightenScaleMode.Linear;
	public const StraightenScaleMode D2D1_STRAIGHTEN_SCALE_MODE_CUBIC = StraightenScaleMode.Cubic;
	public const StraightenScaleMode D2D1_STRAIGHTEN_SCALE_MODE_MULTI_SAMPLE_LINEAR = StraightenScaleMode.MultiSampleLinear;
	public const StraightenScaleMode D2D1_STRAIGHTEN_SCALE_MODE_ANISOTROPIC = StraightenScaleMode.Anisotropic;
	public const TemperatureandtintProp D2D1_TEMPERATUREANDTINT_PROP_TEMPERATURE = TemperatureandtintProp.Temperature;
	public const TemperatureandtintProp D2D1_TEMPERATUREANDTINT_PROP_TINT = TemperatureandtintProp.Tint;
	public const VignetteProp D2D1_VIGNETTE_PROP_COLOR = VignetteProp.Color;
	public const VignetteProp D2D1_VIGNETTE_PROP_TRANSITION_SIZE = VignetteProp.TransitionSize;
	public const VignetteProp D2D1_VIGNETTE_PROP_STRENGTH = VignetteProp.Strength;
	public const EdgeDetectionProp D2D1_EDGEDETECTION_PROP_STRENGTH = EdgeDetectionProp.Strength;
	public const EdgeDetectionProp D2D1_EDGEDETECTION_PROP_BLUR_RADIUS = EdgeDetectionProp.BlurRadius;
	public const EdgeDetectionProp D2D1_EDGEDETECTION_PROP_MODE = EdgeDetectionProp.Mode;
	public const EdgeDetectionProp D2D1_EDGEDETECTION_PROP_OVERLAY_EDGES = EdgeDetectionProp.OverlayEdges;
	public const EdgeDetectionProp D2D1_EDGEDETECTION_PROP_ALPHA_MODE = EdgeDetectionProp.AlphaMode;
	public const EdgeDetectionMode D2D1_EDGEDETECTION_MODE_SOBEL = EdgeDetectionMode.Sobel;
	public const EdgeDetectionMode D2D1_EDGEDETECTION_MODE_PREWITT = EdgeDetectionMode.Prewitt;
	public const HighlightSandShadowsProp D2D1_HIGHLIGHTSANDSHADOWS_PROP_HIGHLIGHTS = HighlightSandShadowsProp.Highlights;
	public const HighlightSandShadowsProp D2D1_HIGHLIGHTSANDSHADOWS_PROP_SHADOWS = HighlightSandShadowsProp.Shadows;
	public const HighlightSandShadowsProp D2D1_HIGHLIGHTSANDSHADOWS_PROP_CLARITY = HighlightSandShadowsProp.Clarity;
	public const HighlightSandShadowsProp D2D1_HIGHLIGHTSANDSHADOWS_PROP_INPUT_GAMMA = HighlightSandShadowsProp.InputGamma;
	public const HighlightSandShadowsProp D2D1_HIGHLIGHTSANDSHADOWS_PROP_MASK_BLUR_RADIUS = HighlightSandShadowsProp.MaskBlurRadius;
	public const HighlightSandShadowsInputGamma D2D1_HIGHLIGHTSANDSHADOWS_INPUT_GAMMA_LINEAR = HighlightSandShadowsInputGamma.Linear;
	public const HighlightSandShadowsInputGamma D2D1_HIGHLIGHTSANDSHADOWS_INPUT_GAMMA_SRGB = HighlightSandShadowsInputGamma.Srgb;
	public const LookupTable3DProp D2D1_LOOKUPTABLE3D_PROP_LUT = LookupTable3DProp.Lut;
	public const LookupTable3DProp D2D1_LOOKUPTABLE3D_PROP_ALPHA_MODE = LookupTable3DProp.AlphaMode;
	public const OpacityProp D2D1_OPACITY_PROP_OPACITY = OpacityProp.Opacity;
	public const CrossfadeProp D2D1_CROSSFADE_PROP_WEIGHT = CrossfadeProp.Weight;
	public const TintProp D2D1_TINT_PROP_COLOR = TintProp.Color;
	public const TintProp D2D1_TINT_PROP_CLAMP_OUTPUT = TintProp.ClampOutput;
	public const WhiteLevelAdjustmentProp D2D1_WHITELEVELADJUSTMENT_PROP_INPUT_WHITE_LEVEL = WhiteLevelAdjustmentProp.InputWhiteLevel;
	public const WhiteLevelAdjustmentProp D2D1_WHITELEVELADJUSTMENT_PROP_OUTPUT_WHITE_LEVEL = WhiteLevelAdjustmentProp.OutputWhiteLevel;
	public const HDRTonemapProp D2D1_HDRTONEMAP_PROP_INPUT_MAX_LUMINANCE = HDRTonemapProp.InputMaxLuminance;
	public const HDRTonemapProp D2D1_HDRTONEMAP_PROP_OUTPUT_MAX_LUMINANCE = HDRTonemapProp.OutputMaxLuminance;
	public const HDRTonemapProp D2D1_HDRTONEMAP_PROP_DISPLAY_MODE = HDRTonemapProp.DisplayMode;
	public const HDRTonemapDisplayMode D2D1_HDRTONEMAP_DISPLAY_MODE_SDR = HDRTonemapDisplayMode.Sdr;
	public const HDRTonemapDisplayMode D2D1_HDRTONEMAP_DISPLAY_MODE_HDR = HDRTonemapDisplayMode.HDR;
	public const RenderingPriority D2D1_RENDERING_PRIORITY_NORMAL = RenderingPriority.Normal;
	public const RenderingPriority D2D1_RENDERING_PRIORITY_LOW = RenderingPriority.Low;
	public const SvgPaintType D2D1_SVG_PAINT_TYPE_NONE = SvgPaintType.None;
	public const SvgPaintType D2D1_SVG_PAINT_TYPE_COLOR = SvgPaintType.Color;
	public const SvgPaintType D2D1_SVG_PAINT_TYPE_CURRENT_COLOR = SvgPaintType.CurrentColor;
	public const SvgPaintType D2D1_SVG_PAINT_TYPE_URI = SvgPaintType.Uri;
	public const SvgPaintType D2D1_SVG_PAINT_TYPE_URI_NONE = SvgPaintType.UriNone;
	public const SvgPaintType D2D1_SVG_PAINT_TYPE_URI_COLOR = SvgPaintType.UriColor;
	public const SvgPaintType D2D1_SVG_PAINT_TYPE_URI_CURRENT_COLOR = SvgPaintType.UriCurrentColor;
	public const SvgLengthUnits D2D1_SVG_LENGTH_UNITS_NUMBER = SvgLengthUnits.Number;
	public const SvgLengthUnits D2D1_SVG_LENGTH_UNITS_PERCENTAGE = SvgLengthUnits.Percentage;
	public const SvgDisplay D2D1_SVG_DISPLAY_INLINE = SvgDisplay.Inline;
	public const SvgDisplay D2D1_SVG_DISPLAY_NONE = SvgDisplay.None;
	public const SvgVisibility D2D1_SVG_VISIBILITY_VISIBLE = SvgVisibility.Visible;
	public const SvgVisibility D2D1_SVG_VISIBILITY_HIDDEN = SvgVisibility.Hidden;
	public const SvgOverflow D2D1_SVG_OVERFLOW_VISIBLE = SvgOverflow.Visible;
	public const SvgOverflow D2D1_SVG_OVERFLOW_HIDDEN = SvgOverflow.Hidden;
	public const SvgLineCap D2D1_SVG_LINE_CAP_BUTT = SvgLineCap.Butt;
	public const SvgLineCap D2D1_SVG_LINE_CAP_SQUARE = SvgLineCap.Square;
	public const SvgLineCap D2D1_SVG_LINE_CAP_ROUND = SvgLineCap.Round;
	public const SvgLineJoin D2D1_SVG_LINE_JOIN_BEVEL = SvgLineJoin.Bevel;
	public const SvgLineJoin D2D1_SVG_LINE_JOIN_MITER = SvgLineJoin.Miter;
	public const SvgLineJoin D2D1_SVG_LINE_JOIN_ROUND = SvgLineJoin.Round;
	public const SvgAspectAlign D2D1_SVG_ASPECT_ALIGN_NONE = SvgAspectAlign.None;
	public const SvgAspectAlign D2D1_SVG_ASPECT_ALIGN_X_MIN_Y_MIN = SvgAspectAlign.XMinYMin;
	public const SvgAspectAlign D2D1_SVG_ASPECT_ALIGN_X_MID_Y_MIN = SvgAspectAlign.XMidYMin;
	public const SvgAspectAlign D2D1_SVG_ASPECT_ALIGN_X_MAX_Y_MIN = SvgAspectAlign.XMaxYMin;
	public const SvgAspectAlign D2D1_SVG_ASPECT_ALIGN_X_MIN_Y_MID = SvgAspectAlign.XMinYMid;
	public const SvgAspectAlign D2D1_SVG_ASPECT_ALIGN_X_MID_Y_MID = SvgAspectAlign.XMidYMid;
	public const SvgAspectAlign D2D1_SVG_ASPECT_ALIGN_X_MAX_Y_MID = SvgAspectAlign.XMaxYMid;
	public const SvgAspectAlign D2D1_SVG_ASPECT_ALIGN_X_MIN_Y_MAX = SvgAspectAlign.XMinYMax;
	public const SvgAspectAlign D2D1_SVG_ASPECT_ALIGN_X_MID_Y_MAX = SvgAspectAlign.XMidYMax;
	public const SvgAspectAlign D2D1_SVG_ASPECT_ALIGN_X_MAX_Y_MAX = SvgAspectAlign.XMaxYMax;
	public const SvgAspectScaling D2D1_SVG_ASPECT_SCALING_MEET = SvgAspectScaling.Meet;
	public const SvgAspectScaling D2D1_SVG_ASPECT_SCALING_SLICE = SvgAspectScaling.Slice;
	public const SvgPathCommand D2D1_SVG_PATH_COMMAND_CLOSE_PATH = SvgPathCommand.ClosePath;
	public const SvgPathCommand D2D1_SVG_PATH_COMMAND_MOVE_ABSOLUTE = SvgPathCommand.MoveAbsolute;
	public const SvgPathCommand D2D1_SVG_PATH_COMMAND_MOVE_RELATIVE = SvgPathCommand.MoveRelative;
	public const SvgPathCommand D2D1_SVG_PATH_COMMAND_LINE_ABSOLUTE = SvgPathCommand.LineAbsolute;
	public const SvgPathCommand D2D1_SVG_PATH_COMMAND_LINE_RELATIVE = SvgPathCommand.LineRelative;
	public const SvgPathCommand D2D1_SVG_PATH_COMMAND_CUBIC_ABSOLUTE = SvgPathCommand.CubicAbsolute;
	public const SvgPathCommand D2D1_SVG_PATH_COMMAND_CUBIC_RELATIVE = SvgPathCommand.CubicRelative;
	public const SvgPathCommand D2D1_SVG_PATH_COMMAND_QUADRADIC_ABSOLUTE = SvgPathCommand.QuadradicAbsolute;
	public const SvgPathCommand D2D1_SVG_PATH_COMMAND_QUADRADIC_RELATIVE = SvgPathCommand.QuadradicRelative;
	public const SvgPathCommand D2D1_SVG_PATH_COMMAND_ARC_ABSOLUTE = SvgPathCommand.ArcAbsolute;
	public const SvgPathCommand D2D1_SVG_PATH_COMMAND_ARC_RELATIVE = SvgPathCommand.ArcRelative;
	public const SvgPathCommand D2D1_SVG_PATH_COMMAND_HORIZONTAL_ABSOLUTE = SvgPathCommand.HorizontalAbsolute;
	public const SvgPathCommand D2D1_SVG_PATH_COMMAND_HORIZONTAL_RELATIVE = SvgPathCommand.HorizontalRelative;
	public const SvgPathCommand D2D1_SVG_PATH_COMMAND_VERTICAL_ABSOLUTE = SvgPathCommand.VerticalAbsolute;
	public const SvgPathCommand D2D1_SVG_PATH_COMMAND_VERTICAL_RELATIVE = SvgPathCommand.VerticalRelative;
	public const SvgPathCommand D2D1_SVG_PATH_COMMAND_CUBIC_SMOOTH_ABSOLUTE = SvgPathCommand.CubicSmoothAbsolute;
	public const SvgPathCommand D2D1_SVG_PATH_COMMAND_CUBIC_SMOOTH_RELATIVE = SvgPathCommand.CubicSmoothRelative;
	public const SvgPathCommand D2D1_SVG_PATH_COMMAND_QUADRADIC_SMOOTH_ABSOLUTE = SvgPathCommand.QuadradicSmoothAbsolute;
	public const SvgPathCommand D2D1_SVG_PATH_COMMAND_QUADRADIC_SMOOTH_RELATIVE = SvgPathCommand.QuadradicSmoothRelative;
	public const SvgUnitType D2D1_SVG_UNIT_TYPE_USER_SPACE_ON_USE = SvgUnitType.UserSpaceOnUse;
	public const SvgUnitType D2D1_SVG_UNIT_TYPE_OBJECT_BOUNDING_BOX = SvgUnitType.ObjectBoundingBox;
	public const SvgAttributeStringType D2D1_SVG_ATTRIBUTE_STRING_TYPE_SVG = SvgAttributeStringType.Svg;
	public const SvgAttributeStringType D2D1_SVG_ATTRIBUTE_STRING_TYPE_ID = SvgAttributeStringType.Id;
	public const SvgAttributePodType D2D1_SVG_ATTRIBUTE_POD_TYPE_FLOAT = SvgAttributePodType.Float;
	public const SvgAttributePodType D2D1_SVG_ATTRIBUTE_POD_TYPE_COLOR = SvgAttributePodType.Color;
	public const SvgAttributePodType D2D1_SVG_ATTRIBUTE_POD_TYPE_FILL_MODE = SvgAttributePodType.FillMode;
	public const SvgAttributePodType D2D1_SVG_ATTRIBUTE_POD_TYPE_DISPLAY = SvgAttributePodType.Display;
	public const SvgAttributePodType D2D1_SVG_ATTRIBUTE_POD_TYPE_OVERFLOW = SvgAttributePodType.Overflow;
	public const SvgAttributePodType D2D1_SVG_ATTRIBUTE_POD_TYPE_LINE_CAP = SvgAttributePodType.LineCap;
	public const SvgAttributePodType D2D1_SVG_ATTRIBUTE_POD_TYPE_LINE_JOIN = SvgAttributePodType.LineJoin;
	public const SvgAttributePodType D2D1_SVG_ATTRIBUTE_POD_TYPE_VISIBILITY = SvgAttributePodType.Visibility;
	public const SvgAttributePodType D2D1_SVG_ATTRIBUTE_POD_TYPE_MATRIX = SvgAttributePodType.Matrix;
	public const SvgAttributePodType D2D1_SVG_ATTRIBUTE_POD_TYPE_UNIT_TYPE = SvgAttributePodType.UnitType;
	public const SvgAttributePodType D2D1_SVG_ATTRIBUTE_POD_TYPE_EXTEND_MODE = SvgAttributePodType.ExtendMode;
	public const SvgAttributePodType D2D1_SVG_ATTRIBUTE_POD_TYPE_PRESERVE_ASPECT_RATIO = SvgAttributePodType.PreserveAspectRatio;
	public const SvgAttributePodType D2D1_SVG_ATTRIBUTE_POD_TYPE_VIEWBOX = SvgAttributePodType.Viewbox;
	public const SvgAttributePodType D2D1_SVG_ATTRIBUTE_POD_TYPE_LENGTH = SvgAttributePodType.Length;
	public const InkNibShape D2D1_INK_NIB_SHAPE_ROUND = InkNibShape.Round;
	public const InkNibShape D2D1_INK_NIB_SHAPE_SQUARE = InkNibShape.Square;
	public const Orientation D2D1_ORIENTATION_DEFAULT = Orientation.Default;
	public const Orientation D2D1_ORIENTATION_FLIP_HORIZONTAL = Orientation.FlipHorizontal;
	public const Orientation D2D1_ORIENTATION_ROTATE_CLOCKWISE180 = Orientation.RotateClockwise180;
	public const Orientation D2D1_ORIENTATION_ROTATE_CLOCKWISE180_FLIP_HORIZONTAL = Orientation.RotateClockwise180FlipHorizontal;
	public const Orientation D2D1_ORIENTATION_ROTATE_CLOCKWISE90_FLIP_HORIZONTAL = Orientation.RotateClockwise90FlipHorizontal;
	public const Orientation D2D1_ORIENTATION_ROTATE_CLOCKWISE270 = Orientation.RotateClockwise270;
	public const Orientation D2D1_ORIENTATION_ROTATE_CLOCKWISE270_FLIP_HORIZONTAL = Orientation.RotateClockwise270FlipHorizontal;
	public const Orientation D2D1_ORIENTATION_ROTATE_CLOCKWISE90 = Orientation.RotateClockwise90;
	public const ImageSourceLoadingOptions D2D1_IMAGE_SOURCE_LOADING_OPTIONS_NONE = ImageSourceLoadingOptions.None;
	public const ImageSourceLoadingOptions D2D1_IMAGE_SOURCE_LOADING_OPTIONS_RELEASE_SOURCE = ImageSourceLoadingOptions.ReleaseSource;
	public const ImageSourceLoadingOptions D2D1_IMAGE_SOURCE_LOADING_OPTIONS_CACHE_ON_DEMAND = ImageSourceLoadingOptions.CacheOnDemand;
	public const ImageSourceFromDxgiOptions D2D1_IMAGE_SOURCE_FROM_DXGI_OPTIONS_NONE = ImageSourceFromDxgiOptions.None;
	public const ImageSourceFromDxgiOptions D2D1_IMAGE_SOURCE_FROM_DXGI_OPTIONS_LOW_QUALITY_PRIMARY_CONVERSION = ImageSourceFromDxgiOptions.LowQualityPrimaryConversion;
	public const TransformedImageSourceOptions D2D1_TRANSFORMED_IMAGE_SOURCE_OPTIONS_NONE = TransformedImageSourceOptions.None;
	public const TransformedImageSourceOptions D2D1_TRANSFORMED_IMAGE_SOURCE_OPTIONS_DISABLE_DPI_SCALE = TransformedImageSourceOptions.DisableDpiScale;
	public const PatchEdgeMode D2D1_PATCH_EDGE_MODE_ALIASED = PatchEdgeMode.Aliased;
	public const PatchEdgeMode D2D1_PATCH_EDGE_MODE_ANTIALIASED = PatchEdgeMode.Antialiased;
	public const PatchEdgeMode D2D1_PATCH_EDGE_MODE_ALIASED_INFLATED = PatchEdgeMode.AliasedInflated;
	public const SpriteOptions D2D1_SPRITE_OPTIONS_NONE = SpriteOptions.None;
	public const SpriteOptions D2D1_SPRITE_OPTIONS_CLAMP_TO_SOURCE_RECTANGLE = SpriteOptions.ClampToSourceRectangle;
	public const ColorBitmapGlyphSnapOption D2D1_COLOR_BITMAP_GLYPH_SNAP_OPTION_DEFAULT = ColorBitmapGlyphSnapOption.Default;
	public const ColorBitmapGlyphSnapOption D2D1_COLOR_BITMAP_GLYPH_SNAP_OPTION_DISABLE = ColorBitmapGlyphSnapOption.Disable;
	public const Gamma1 D2D1_GAMMA1_G22 = Gamma1.G22;
	public const Gamma1 D2D1_GAMMA1_G10 = Gamma1.G10;
	public const Gamma1 D2D1_GAMMA1_G2084 = Gamma1.G2084;
	public const ColorContextType D2D1_COLOR_CONTEXT_TYPE_ICC = ColorContextType.Icc;
	public const ColorContextType D2D1_COLOR_CONTEXT_TYPE_SIMPLE = ColorContextType.Simple;
	public const ColorContextType D2D1_COLOR_CONTEXT_TYPE_DXGI = ColorContextType.DXGI;
}

