diff --git a/Directory.Build.props b/Directory.Build.props
index 7a95603..1be8491 100644
--- a/Directory.Build.props
+++ b/Directory.Build.props
@@ -14,7 +14,7 @@
     <EnableTrimAnalyzer>true</EnableTrimAnalyzer>
     <RestoreConfigFile>$(MSBuildThisFileDirectory)NuGet.config</RestoreConfigFile>
 
-    <VersionPrefix>1.9.31</VersionPrefix>
+    <VersionPrefix>1.9.32</VersionPrefix>
     <VersionSuffix Condition="'$(VersionSuffix)' == ''"></VersionSuffix>
     
     <GenerateDocumentationFile>true</GenerateDocumentationFile>
diff --git a/src/Generator/Program.cs b/src/Generator/Program.cs
index 965e83b..5cef6f3 100644
--- a/src/Generator/Program.cs
+++ b/src/Generator/Program.cs
@@ -2114,21 +2114,7 @@ public static class Program
                     fieldValueName = "Mask";
                 }
 
-                bool asPointer = false;
-                if (field.Type.Kind == "ApiRef")
-                {
-                    string lookupApiName = GetApiName(field.Type);
-                    string fullTypeName = $"{lookupApiName}.{field.Type.Name}";
-
-                    if (IsKnownComType(fullTypeName) ||
-                        s_visitedComTypes.ContainsKey(fullTypeName) ||
-                        api.Types.Any(item => item.Name == field.Type.Name && item.Kind.ToLowerInvariant() == "com"))
-                    {
-                        asPointer = true;
-                    }
-                }
-
-                string fieldTypeName = GetTypeName(field.Type, asPointer);
+                string fieldTypeName = GetTypeNameWithPointerCheck(api, field.Type);
                 if (string.IsNullOrEmpty(writer.DocFileName) == false)
                 {
                     writer.WriteLine($"/// <include file='{writer.DocFileName}.xml' path='doc/member[@name=\"{structType.Name}::{field.Name}\"]/*' />");
@@ -2460,7 +2446,7 @@ public static class Program
                     }
 
                     // TODO: Handle inherit
-                    string returnType = GetTypeName(method.ReturnType);
+                    string returnType = GetTypeNameWithPointerCheck(api, method.ReturnType);
 
                     StringBuilder argumentBuilder = new();
                     StringBuilder argumentsTypesBuilder = new();
@@ -3225,6 +3211,25 @@ public static class Program
         return apiName;
     }
 
+    private static string GetTypeNameWithPointerCheck(ApiData api, ApiDataType dataType)
+    {
+        bool asPointer = false;
+        if (dataType.Kind == "ApiRef")
+        {
+            string lookupApiName = GetApiName(dataType);
+            string fullTypeName = $"{lookupApiName}.{dataType.Name}";
+
+            if (IsKnownComType(fullTypeName) ||
+                s_visitedComTypes.ContainsKey(fullTypeName) ||
+                api.Types.Any(item => item.Name == dataType.Name && item.Kind.ToLowerInvariant() == "com"))
+            {
+                asPointer = true;
+            }
+        }
+
+        return GetTypeName(dataType, asPointer);
+    }
+
     private static string GetTypeName(ApiDataType dataType, bool asPointer = false)
     {
         if (dataType.Kind == "ApiRef")
diff --git a/src/Vortice.Win32.Graphics.Direct3D11/Generated/ID3D11FunctionReflection.cs b/src/Vortice.Win32.Graphics.Direct3D11/Generated/ID3D11FunctionReflection.cs
index cbe0e49..b532f0b 100644
--- a/src/Vortice.Win32.Graphics.Direct3D11/Generated/ID3D11FunctionReflection.cs
+++ b/src/Vortice.Win32.Graphics.Direct3D11/Generated/ID3D11FunctionReflection.cs
@@ -61,24 +61,24 @@ public unsafe partial struct ID3D11FunctionReflection : ID3D11FunctionReflection
 	/// <include file='../Direct3D11.xml' path='doc/member[@name="ID3D11FunctionReflection::GetConstantBufferByIndex"]/*' />
 	[MethodImpl(MethodImplOptions.AggressiveInlining)]
 	[VtblIndex(1)]
-	public ID3D11ShaderReflectionConstantBuffer GetConstantBufferByIndex(uint BufferIndex)
+	public ID3D11ShaderReflectionConstantBuffer* GetConstantBufferByIndex(uint BufferIndex)
 	{
 #if NET6_0_OR_GREATER
-		return ((delegate* unmanaged<ID3D11FunctionReflection*, uint, ID3D11ShaderReflectionConstantBuffer>)(lpVtbl[1]))((ID3D11FunctionReflection*)Unsafe.AsPointer(ref this), BufferIndex);
+		return ((delegate* unmanaged<ID3D11FunctionReflection*, uint, ID3D11ShaderReflectionConstantBuffer*>)(lpVtbl[1]))((ID3D11FunctionReflection*)Unsafe.AsPointer(ref this), BufferIndex);
 #else
-		return ((delegate* unmanaged[Stdcall]<ID3D11FunctionReflection*, uint, ID3D11ShaderReflectionConstantBuffer>)(lpVtbl[1]))((ID3D11FunctionReflection*)Unsafe.AsPointer(ref this), BufferIndex);
+		return ((delegate* unmanaged[Stdcall]<ID3D11FunctionReflection*, uint, ID3D11ShaderReflectionConstantBuffer*>)(lpVtbl[1]))((ID3D11FunctionReflection*)Unsafe.AsPointer(ref this), BufferIndex);
 #endif
 	}
 
 	/// <include file='../Direct3D11.xml' path='doc/member[@name="ID3D11FunctionReflection::GetConstantBufferByName"]/*' />
 	[MethodImpl(MethodImplOptions.AggressiveInlining)]
 	[VtblIndex(2)]
-	public ID3D11ShaderReflectionConstantBuffer GetConstantBufferByName(sbyte* Name)
+	public ID3D11ShaderReflectionConstantBuffer* GetConstantBufferByName(sbyte* Name)
 	{
 #if NET6_0_OR_GREATER
-		return ((delegate* unmanaged<ID3D11FunctionReflection*, sbyte*, ID3D11ShaderReflectionConstantBuffer>)(lpVtbl[2]))((ID3D11FunctionReflection*)Unsafe.AsPointer(ref this), Name);
+		return ((delegate* unmanaged<ID3D11FunctionReflection*, sbyte*, ID3D11ShaderReflectionConstantBuffer*>)(lpVtbl[2]))((ID3D11FunctionReflection*)Unsafe.AsPointer(ref this), Name);
 #else
-		return ((delegate* unmanaged[Stdcall]<ID3D11FunctionReflection*, sbyte*, ID3D11ShaderReflectionConstantBuffer>)(lpVtbl[2]))((ID3D11FunctionReflection*)Unsafe.AsPointer(ref this), Name);
+		return ((delegate* unmanaged[Stdcall]<ID3D11FunctionReflection*, sbyte*, ID3D11ShaderReflectionConstantBuffer*>)(lpVtbl[2]))((ID3D11FunctionReflection*)Unsafe.AsPointer(ref this), Name);
 #endif
 	}
 
@@ -97,12 +97,12 @@ public unsafe partial struct ID3D11FunctionReflection : ID3D11FunctionReflection
 	/// <include file='../Direct3D11.xml' path='doc/member[@name="ID3D11FunctionReflection::GetVariableByName"]/*' />
 	[MethodImpl(MethodImplOptions.AggressiveInlining)]
 	[VtblIndex(4)]
-	public ID3D11ShaderReflectionVariable GetVariableByName(sbyte* Name)
+	public ID3D11ShaderReflectionVariable* GetVariableByName(sbyte* Name)
 	{
 #if NET6_0_OR_GREATER
-		return ((delegate* unmanaged<ID3D11FunctionReflection*, sbyte*, ID3D11ShaderReflectionVariable>)(lpVtbl[4]))((ID3D11FunctionReflection*)Unsafe.AsPointer(ref this), Name);
+		return ((delegate* unmanaged<ID3D11FunctionReflection*, sbyte*, ID3D11ShaderReflectionVariable*>)(lpVtbl[4]))((ID3D11FunctionReflection*)Unsafe.AsPointer(ref this), Name);
 #else
-		return ((delegate* unmanaged[Stdcall]<ID3D11FunctionReflection*, sbyte*, ID3D11ShaderReflectionVariable>)(lpVtbl[4]))((ID3D11FunctionReflection*)Unsafe.AsPointer(ref this), Name);
+		return ((delegate* unmanaged[Stdcall]<ID3D11FunctionReflection*, sbyte*, ID3D11ShaderReflectionVariable*>)(lpVtbl[4]))((ID3D11FunctionReflection*)Unsafe.AsPointer(ref this), Name);
 #endif
 	}
 
@@ -121,12 +121,12 @@ public unsafe partial struct ID3D11FunctionReflection : ID3D11FunctionReflection
 	/// <include file='../Direct3D11.xml' path='doc/member[@name="ID3D11FunctionReflection::GetFunctionParameter"]/*' />
 	[MethodImpl(MethodImplOptions.AggressiveInlining)]
 	[VtblIndex(6)]
-	public ID3D11FunctionParameterReflection GetFunctionParameter(int ParameterIndex)
+	public ID3D11FunctionParameterReflection* GetFunctionParameter(int ParameterIndex)
 	{
 #if NET6_0_OR_GREATER
-		return ((delegate* unmanaged<ID3D11FunctionReflection*, int, ID3D11FunctionParameterReflection>)(lpVtbl[6]))((ID3D11FunctionReflection*)Unsafe.AsPointer(ref this), ParameterIndex);
+		return ((delegate* unmanaged<ID3D11FunctionReflection*, int, ID3D11FunctionParameterReflection*>)(lpVtbl[6]))((ID3D11FunctionReflection*)Unsafe.AsPointer(ref this), ParameterIndex);
 #else
-		return ((delegate* unmanaged[Stdcall]<ID3D11FunctionReflection*, int, ID3D11FunctionParameterReflection>)(lpVtbl[6]))((ID3D11FunctionReflection*)Unsafe.AsPointer(ref this), ParameterIndex);
+		return ((delegate* unmanaged[Stdcall]<ID3D11FunctionReflection*, int, ID3D11FunctionParameterReflection*>)(lpVtbl[6]))((ID3D11FunctionReflection*)Unsafe.AsPointer(ref this), ParameterIndex);
 #endif
 	}
 
@@ -136,22 +136,22 @@ public unsafe partial struct ID3D11FunctionReflection : ID3D11FunctionReflection
 		HResult GetDesc(FunctionDescription* pDesc);
 
 		[VtblIndex(1)]
-		ID3D11ShaderReflectionConstantBuffer GetConstantBufferByIndex(uint BufferIndex);
+		ID3D11ShaderReflectionConstantBuffer* GetConstantBufferByIndex(uint BufferIndex);
 
 		[VtblIndex(2)]
-		ID3D11ShaderReflectionConstantBuffer GetConstantBufferByName(sbyte* Name);
+		ID3D11ShaderReflectionConstantBuffer* GetConstantBufferByName(sbyte* Name);
 
 		[VtblIndex(3)]
 		HResult GetResourceBindingDesc(uint ResourceIndex, ShaderInputBindDescription* pDesc);
 
 		[VtblIndex(4)]
-		ID3D11ShaderReflectionVariable GetVariableByName(sbyte* Name);
+		ID3D11ShaderReflectionVariable* GetVariableByName(sbyte* Name);
 
 		[VtblIndex(5)]
 		HResult GetResourceBindingDescByName(sbyte* Name, ShaderInputBindDescription* pDesc);
 
 		[VtblIndex(6)]
-		ID3D11FunctionParameterReflection GetFunctionParameter(int ParameterIndex);
+		ID3D11FunctionParameterReflection* GetFunctionParameter(int ParameterIndex);
 	}
 }
 
diff --git a/src/Vortice.Win32.Graphics.Direct3D11/Generated/ID3D11LibraryReflection.cs b/src/Vortice.Win32.Graphics.Direct3D11/Generated/ID3D11LibraryReflection.cs
index 157e0a4..d23c35e 100644
--- a/src/Vortice.Win32.Graphics.Direct3D11/Generated/ID3D11LibraryReflection.cs
+++ b/src/Vortice.Win32.Graphics.Direct3D11/Generated/ID3D11LibraryReflection.cs
@@ -101,12 +101,12 @@ public unsafe partial struct ID3D11LibraryReflection : ID3D11LibraryReflection.I
 	/// <include file='../Direct3D11.xml' path='doc/member[@name="ID3D11LibraryReflection::GetFunctionByIndex"]/*' />
 	[MethodImpl(MethodImplOptions.AggressiveInlining)]
 	[VtblIndex(4)]
-	public ID3D11FunctionReflection GetFunctionByIndex(int FunctionIndex)
+	public ID3D11FunctionReflection* GetFunctionByIndex(int FunctionIndex)
 	{
 #if NET6_0_OR_GREATER
-		return ((delegate* unmanaged<ID3D11LibraryReflection*, int, ID3D11FunctionReflection>)(lpVtbl[4]))((ID3D11LibraryReflection*)Unsafe.AsPointer(ref this), FunctionIndex);
+		return ((delegate* unmanaged<ID3D11LibraryReflection*, int, ID3D11FunctionReflection*>)(lpVtbl[4]))((ID3D11LibraryReflection*)Unsafe.AsPointer(ref this), FunctionIndex);
 #else
-		return ((delegate* unmanaged[Stdcall]<ID3D11LibraryReflection*, int, ID3D11FunctionReflection>)(lpVtbl[4]))((ID3D11LibraryReflection*)Unsafe.AsPointer(ref this), FunctionIndex);
+		return ((delegate* unmanaged[Stdcall]<ID3D11LibraryReflection*, int, ID3D11FunctionReflection*>)(lpVtbl[4]))((ID3D11LibraryReflection*)Unsafe.AsPointer(ref this), FunctionIndex);
 #endif
 	}
 
@@ -116,7 +116,7 @@ public unsafe partial struct ID3D11LibraryReflection : ID3D11LibraryReflection.I
 		HResult GetDesc(LibraryDescription* pDesc);
 
 		[VtblIndex(4)]
-		ID3D11FunctionReflection GetFunctionByIndex(int FunctionIndex);
+		ID3D11FunctionReflection* GetFunctionByIndex(int FunctionIndex);
 	}
 }
 
diff --git a/src/Vortice.Win32.Graphics.Direct3D11/Generated/ID3D11ShaderReflection.cs b/src/Vortice.Win32.Graphics.Direct3D11/Generated/ID3D11ShaderReflection.cs
index 95c57ae..8320526 100644
--- a/src/Vortice.Win32.Graphics.Direct3D11/Generated/ID3D11ShaderReflection.cs
+++ b/src/Vortice.Win32.Graphics.Direct3D11/Generated/ID3D11ShaderReflection.cs
@@ -101,24 +101,24 @@ public unsafe partial struct ID3D11ShaderReflection : ID3D11ShaderReflection.Int
 	/// <include file='../Direct3D11.xml' path='doc/member[@name="ID3D11ShaderReflection::GetConstantBufferByIndex"]/*' />
 	[MethodImpl(MethodImplOptions.AggressiveInlining)]
 	[VtblIndex(4)]
-	public ID3D11ShaderReflectionConstantBuffer GetConstantBufferByIndex(uint Index)
+	public ID3D11ShaderReflectionConstantBuffer* GetConstantBufferByIndex(uint Index)
 	{
 #if NET6_0_OR_GREATER
-		return ((delegate* unmanaged<ID3D11ShaderReflection*, uint, ID3D11ShaderReflectionConstantBuffer>)(lpVtbl[4]))((ID3D11ShaderReflection*)Unsafe.AsPointer(ref this), Index);
+		return ((delegate* unmanaged<ID3D11ShaderReflection*, uint, ID3D11ShaderReflectionConstantBuffer*>)(lpVtbl[4]))((ID3D11ShaderReflection*)Unsafe.AsPointer(ref this), Index);
 #else
-		return ((delegate* unmanaged[Stdcall]<ID3D11ShaderReflection*, uint, ID3D11ShaderReflectionConstantBuffer>)(lpVtbl[4]))((ID3D11ShaderReflection*)Unsafe.AsPointer(ref this), Index);
+		return ((delegate* unmanaged[Stdcall]<ID3D11ShaderReflection*, uint, ID3D11ShaderReflectionConstantBuffer*>)(lpVtbl[4]))((ID3D11ShaderReflection*)Unsafe.AsPointer(ref this), Index);
 #endif
 	}
 
 	/// <include file='../Direct3D11.xml' path='doc/member[@name="ID3D11ShaderReflection::GetConstantBufferByName"]/*' />
 	[MethodImpl(MethodImplOptions.AggressiveInlining)]
 	[VtblIndex(5)]
-	public ID3D11ShaderReflectionConstantBuffer GetConstantBufferByName(sbyte* Name)
+	public ID3D11ShaderReflectionConstantBuffer* GetConstantBufferByName(sbyte* Name)
 	{
 #if NET6_0_OR_GREATER
-		return ((delegate* unmanaged<ID3D11ShaderReflection*, sbyte*, ID3D11ShaderReflectionConstantBuffer>)(lpVtbl[5]))((ID3D11ShaderReflection*)Unsafe.AsPointer(ref this), Name);
+		return ((delegate* unmanaged<ID3D11ShaderReflection*, sbyte*, ID3D11ShaderReflectionConstantBuffer*>)(lpVtbl[5]))((ID3D11ShaderReflection*)Unsafe.AsPointer(ref this), Name);
 #else
-		return ((delegate* unmanaged[Stdcall]<ID3D11ShaderReflection*, sbyte*, ID3D11ShaderReflectionConstantBuffer>)(lpVtbl[5]))((ID3D11ShaderReflection*)Unsafe.AsPointer(ref this), Name);
+		return ((delegate* unmanaged[Stdcall]<ID3D11ShaderReflection*, sbyte*, ID3D11ShaderReflectionConstantBuffer*>)(lpVtbl[5]))((ID3D11ShaderReflection*)Unsafe.AsPointer(ref this), Name);
 #endif
 	}
 
@@ -173,12 +173,12 @@ public unsafe partial struct ID3D11ShaderReflection : ID3D11ShaderReflection.Int
 	/// <include file='../Direct3D11.xml' path='doc/member[@name="ID3D11ShaderReflection::GetVariableByName"]/*' />
 	[MethodImpl(MethodImplOptions.AggressiveInlining)]
 	[VtblIndex(10)]
-	public ID3D11ShaderReflectionVariable GetVariableByName(sbyte* Name)
+	public ID3D11ShaderReflectionVariable* GetVariableByName(sbyte* Name)
 	{
 #if NET6_0_OR_GREATER
-		return ((delegate* unmanaged<ID3D11ShaderReflection*, sbyte*, ID3D11ShaderReflectionVariable>)(lpVtbl[10]))((ID3D11ShaderReflection*)Unsafe.AsPointer(ref this), Name);
+		return ((delegate* unmanaged<ID3D11ShaderReflection*, sbyte*, ID3D11ShaderReflectionVariable*>)(lpVtbl[10]))((ID3D11ShaderReflection*)Unsafe.AsPointer(ref this), Name);
 #else
-		return ((delegate* unmanaged[Stdcall]<ID3D11ShaderReflection*, sbyte*, ID3D11ShaderReflectionVariable>)(lpVtbl[10]))((ID3D11ShaderReflection*)Unsafe.AsPointer(ref this), Name);
+		return ((delegate* unmanaged[Stdcall]<ID3D11ShaderReflection*, sbyte*, ID3D11ShaderReflectionVariable*>)(lpVtbl[10]))((ID3D11ShaderReflection*)Unsafe.AsPointer(ref this), Name);
 #endif
 	}
 
@@ -320,10 +320,10 @@ public unsafe partial struct ID3D11ShaderReflection : ID3D11ShaderReflection.Int
 		HResult GetDesc(ShaderDescription* pDesc);
 
 		[VtblIndex(4)]
-		ID3D11ShaderReflectionConstantBuffer GetConstantBufferByIndex(uint Index);
+		ID3D11ShaderReflectionConstantBuffer* GetConstantBufferByIndex(uint Index);
 
 		[VtblIndex(5)]
-		ID3D11ShaderReflectionConstantBuffer GetConstantBufferByName(sbyte* Name);
+		ID3D11ShaderReflectionConstantBuffer* GetConstantBufferByName(sbyte* Name);
 
 		[VtblIndex(6)]
 		HResult GetResourceBindingDesc(uint ResourceIndex, ShaderInputBindDescription* pDesc);
@@ -338,7 +338,7 @@ public unsafe partial struct ID3D11ShaderReflection : ID3D11ShaderReflection.Int
 		HResult GetPatchConstantParameterDesc(uint ParameterIndex, SignatureParameterDescription* pDesc);
 
 		[VtblIndex(10)]
-		ID3D11ShaderReflectionVariable GetVariableByName(sbyte* Name);
+		ID3D11ShaderReflectionVariable* GetVariableByName(sbyte* Name);
 
 		[VtblIndex(11)]
 		HResult GetResourceBindingDescByName(sbyte* Name, ShaderInputBindDescription* pDesc);
diff --git a/src/Vortice.Win32.Graphics.Direct3D11/Generated/ID3D11ShaderReflectionConstantBuffer.cs b/src/Vortice.Win32.Graphics.Direct3D11/Generated/ID3D11ShaderReflectionConstantBuffer.cs
index 6bb2f4d..1331ae0 100644
--- a/src/Vortice.Win32.Graphics.Direct3D11/Generated/ID3D11ShaderReflectionConstantBuffer.cs
+++ b/src/Vortice.Win32.Graphics.Direct3D11/Generated/ID3D11ShaderReflectionConstantBuffer.cs
@@ -61,24 +61,24 @@ public unsafe partial struct ID3D11ShaderReflectionConstantBuffer : ID3D11Shader
 	/// <include file='../Direct3D11.xml' path='doc/member[@name="ID3D11ShaderReflectionConstantBuffer::GetVariableByIndex"]/*' />
 	[MethodImpl(MethodImplOptions.AggressiveInlining)]
 	[VtblIndex(1)]
-	public ID3D11ShaderReflectionVariable GetVariableByIndex(uint Index)
+	public ID3D11ShaderReflectionVariable* GetVariableByIndex(uint Index)
 	{
 #if NET6_0_OR_GREATER
-		return ((delegate* unmanaged<ID3D11ShaderReflectionConstantBuffer*, uint, ID3D11ShaderReflectionVariable>)(lpVtbl[1]))((ID3D11ShaderReflectionConstantBuffer*)Unsafe.AsPointer(ref this), Index);
+		return ((delegate* unmanaged<ID3D11ShaderReflectionConstantBuffer*, uint, ID3D11ShaderReflectionVariable*>)(lpVtbl[1]))((ID3D11ShaderReflectionConstantBuffer*)Unsafe.AsPointer(ref this), Index);
 #else
-		return ((delegate* unmanaged[Stdcall]<ID3D11ShaderReflectionConstantBuffer*, uint, ID3D11ShaderReflectionVariable>)(lpVtbl[1]))((ID3D11ShaderReflectionConstantBuffer*)Unsafe.AsPointer(ref this), Index);
+		return ((delegate* unmanaged[Stdcall]<ID3D11ShaderReflectionConstantBuffer*, uint, ID3D11ShaderReflectionVariable*>)(lpVtbl[1]))((ID3D11ShaderReflectionConstantBuffer*)Unsafe.AsPointer(ref this), Index);
 #endif
 	}
 
 	/// <include file='../Direct3D11.xml' path='doc/member[@name="ID3D11ShaderReflectionConstantBuffer::GetVariableByName"]/*' />
 	[MethodImpl(MethodImplOptions.AggressiveInlining)]
 	[VtblIndex(2)]
-	public ID3D11ShaderReflectionVariable GetVariableByName(sbyte* Name)
+	public ID3D11ShaderReflectionVariable* GetVariableByName(sbyte* Name)
 	{
 #if NET6_0_OR_GREATER
-		return ((delegate* unmanaged<ID3D11ShaderReflectionConstantBuffer*, sbyte*, ID3D11ShaderReflectionVariable>)(lpVtbl[2]))((ID3D11ShaderReflectionConstantBuffer*)Unsafe.AsPointer(ref this), Name);
+		return ((delegate* unmanaged<ID3D11ShaderReflectionConstantBuffer*, sbyte*, ID3D11ShaderReflectionVariable*>)(lpVtbl[2]))((ID3D11ShaderReflectionConstantBuffer*)Unsafe.AsPointer(ref this), Name);
 #else
-		return ((delegate* unmanaged[Stdcall]<ID3D11ShaderReflectionConstantBuffer*, sbyte*, ID3D11ShaderReflectionVariable>)(lpVtbl[2]))((ID3D11ShaderReflectionConstantBuffer*)Unsafe.AsPointer(ref this), Name);
+		return ((delegate* unmanaged[Stdcall]<ID3D11ShaderReflectionConstantBuffer*, sbyte*, ID3D11ShaderReflectionVariable*>)(lpVtbl[2]))((ID3D11ShaderReflectionConstantBuffer*)Unsafe.AsPointer(ref this), Name);
 #endif
 	}
 
@@ -88,10 +88,10 @@ public unsafe partial struct ID3D11ShaderReflectionConstantBuffer : ID3D11Shader
 		HResult GetDesc(ShaderBufferDescription* pDesc);
 
 		[VtblIndex(1)]
-		ID3D11ShaderReflectionVariable GetVariableByIndex(uint Index);
+		ID3D11ShaderReflectionVariable* GetVariableByIndex(uint Index);
 
 		[VtblIndex(2)]
-		ID3D11ShaderReflectionVariable GetVariableByName(sbyte* Name);
+		ID3D11ShaderReflectionVariable* GetVariableByName(sbyte* Name);
 	}
 }
 
diff --git a/src/Vortice.Win32.Graphics.Direct3D11/Generated/ID3D11ShaderReflectionType.cs b/src/Vortice.Win32.Graphics.Direct3D11/Generated/ID3D11ShaderReflectionType.cs
index 749a680..3db88ad 100644
--- a/src/Vortice.Win32.Graphics.Direct3D11/Generated/ID3D11ShaderReflectionType.cs
+++ b/src/Vortice.Win32.Graphics.Direct3D11/Generated/ID3D11ShaderReflectionType.cs
@@ -61,24 +61,24 @@ public unsafe partial struct ID3D11ShaderReflectionType : ID3D11ShaderReflection
 	/// <include file='../Direct3D11.xml' path='doc/member[@name="ID3D11ShaderReflectionType::GetMemberTypeByIndex"]/*' />
 	[MethodImpl(MethodImplOptions.AggressiveInlining)]
 	[VtblIndex(1)]
-	public ID3D11ShaderReflectionType GetMemberTypeByIndex(uint Index)
+	public ID3D11ShaderReflectionType* GetMemberTypeByIndex(uint Index)
 	{
 #if NET6_0_OR_GREATER
-		return ((delegate* unmanaged<ID3D11ShaderReflectionType*, uint, ID3D11ShaderReflectionType>)(lpVtbl[1]))((ID3D11ShaderReflectionType*)Unsafe.AsPointer(ref this), Index);
+		return ((delegate* unmanaged<ID3D11ShaderReflectionType*, uint, ID3D11ShaderReflectionType*>)(lpVtbl[1]))((ID3D11ShaderReflectionType*)Unsafe.AsPointer(ref this), Index);
 #else
-		return ((delegate* unmanaged[Stdcall]<ID3D11ShaderReflectionType*, uint, ID3D11ShaderReflectionType>)(lpVtbl[1]))((ID3D11ShaderReflectionType*)Unsafe.AsPointer(ref this), Index);
+		return ((delegate* unmanaged[Stdcall]<ID3D11ShaderReflectionType*, uint, ID3D11ShaderReflectionType*>)(lpVtbl[1]))((ID3D11ShaderReflectionType*)Unsafe.AsPointer(ref this), Index);
 #endif
 	}
 
 	/// <include file='../Direct3D11.xml' path='doc/member[@name="ID3D11ShaderReflectionType::GetMemberTypeByName"]/*' />
 	[MethodImpl(MethodImplOptions.AggressiveInlining)]
 	[VtblIndex(2)]
-	public ID3D11ShaderReflectionType GetMemberTypeByName(sbyte* Name)
+	public ID3D11ShaderReflectionType* GetMemberTypeByName(sbyte* Name)
 	{
 #if NET6_0_OR_GREATER
-		return ((delegate* unmanaged<ID3D11ShaderReflectionType*, sbyte*, ID3D11ShaderReflectionType>)(lpVtbl[2]))((ID3D11ShaderReflectionType*)Unsafe.AsPointer(ref this), Name);
+		return ((delegate* unmanaged<ID3D11ShaderReflectionType*, sbyte*, ID3D11ShaderReflectionType*>)(lpVtbl[2]))((ID3D11ShaderReflectionType*)Unsafe.AsPointer(ref this), Name);
 #else
-		return ((delegate* unmanaged[Stdcall]<ID3D11ShaderReflectionType*, sbyte*, ID3D11ShaderReflectionType>)(lpVtbl[2]))((ID3D11ShaderReflectionType*)Unsafe.AsPointer(ref this), Name);
+		return ((delegate* unmanaged[Stdcall]<ID3D11ShaderReflectionType*, sbyte*, ID3D11ShaderReflectionType*>)(lpVtbl[2]))((ID3D11ShaderReflectionType*)Unsafe.AsPointer(ref this), Name);
 #endif
 	}
 
@@ -109,24 +109,24 @@ public unsafe partial struct ID3D11ShaderReflectionType : ID3D11ShaderReflection
 	/// <include file='../Direct3D11.xml' path='doc/member[@name="ID3D11ShaderReflectionType::GetSubType"]/*' />
 	[MethodImpl(MethodImplOptions.AggressiveInlining)]
 	[VtblIndex(5)]
-	public ID3D11ShaderReflectionType GetSubType()
+	public ID3D11ShaderReflectionType* GetSubType()
 	{
 #if NET6_0_OR_GREATER
-		return ((delegate* unmanaged<ID3D11ShaderReflectionType*, ID3D11ShaderReflectionType>)(lpVtbl[5]))((ID3D11ShaderReflectionType*)Unsafe.AsPointer(ref this));
+		return ((delegate* unmanaged<ID3D11ShaderReflectionType*, ID3D11ShaderReflectionType*>)(lpVtbl[5]))((ID3D11ShaderReflectionType*)Unsafe.AsPointer(ref this));
 #else
-		return ((delegate* unmanaged[Stdcall]<ID3D11ShaderReflectionType*, ID3D11ShaderReflectionType>)(lpVtbl[5]))((ID3D11ShaderReflectionType*)Unsafe.AsPointer(ref this));
+		return ((delegate* unmanaged[Stdcall]<ID3D11ShaderReflectionType*, ID3D11ShaderReflectionType*>)(lpVtbl[5]))((ID3D11ShaderReflectionType*)Unsafe.AsPointer(ref this));
 #endif
 	}
 
 	/// <include file='../Direct3D11.xml' path='doc/member[@name="ID3D11ShaderReflectionType::GetBaseClass"]/*' />
 	[MethodImpl(MethodImplOptions.AggressiveInlining)]
 	[VtblIndex(6)]
-	public ID3D11ShaderReflectionType GetBaseClass()
+	public ID3D11ShaderReflectionType* GetBaseClass()
 	{
 #if NET6_0_OR_GREATER
-		return ((delegate* unmanaged<ID3D11ShaderReflectionType*, ID3D11ShaderReflectionType>)(lpVtbl[6]))((ID3D11ShaderReflectionType*)Unsafe.AsPointer(ref this));
+		return ((delegate* unmanaged<ID3D11ShaderReflectionType*, ID3D11ShaderReflectionType*>)(lpVtbl[6]))((ID3D11ShaderReflectionType*)Unsafe.AsPointer(ref this));
 #else
-		return ((delegate* unmanaged[Stdcall]<ID3D11ShaderReflectionType*, ID3D11ShaderReflectionType>)(lpVtbl[6]))((ID3D11ShaderReflectionType*)Unsafe.AsPointer(ref this));
+		return ((delegate* unmanaged[Stdcall]<ID3D11ShaderReflectionType*, ID3D11ShaderReflectionType*>)(lpVtbl[6]))((ID3D11ShaderReflectionType*)Unsafe.AsPointer(ref this));
 #endif
 	}
 
@@ -145,12 +145,12 @@ public unsafe partial struct ID3D11ShaderReflectionType : ID3D11ShaderReflection
 	/// <include file='../Direct3D11.xml' path='doc/member[@name="ID3D11ShaderReflectionType::GetInterfaceByIndex"]/*' />
 	[MethodImpl(MethodImplOptions.AggressiveInlining)]
 	[VtblIndex(8)]
-	public ID3D11ShaderReflectionType GetInterfaceByIndex(uint uIndex)
+	public ID3D11ShaderReflectionType* GetInterfaceByIndex(uint uIndex)
 	{
 #if NET6_0_OR_GREATER
-		return ((delegate* unmanaged<ID3D11ShaderReflectionType*, uint, ID3D11ShaderReflectionType>)(lpVtbl[8]))((ID3D11ShaderReflectionType*)Unsafe.AsPointer(ref this), uIndex);
+		return ((delegate* unmanaged<ID3D11ShaderReflectionType*, uint, ID3D11ShaderReflectionType*>)(lpVtbl[8]))((ID3D11ShaderReflectionType*)Unsafe.AsPointer(ref this), uIndex);
 #else
-		return ((delegate* unmanaged[Stdcall]<ID3D11ShaderReflectionType*, uint, ID3D11ShaderReflectionType>)(lpVtbl[8]))((ID3D11ShaderReflectionType*)Unsafe.AsPointer(ref this), uIndex);
+		return ((delegate* unmanaged[Stdcall]<ID3D11ShaderReflectionType*, uint, ID3D11ShaderReflectionType*>)(lpVtbl[8]))((ID3D11ShaderReflectionType*)Unsafe.AsPointer(ref this), uIndex);
 #endif
 	}
 
@@ -184,10 +184,10 @@ public unsafe partial struct ID3D11ShaderReflectionType : ID3D11ShaderReflection
 		HResult GetDesc(ShaderTypeDescription* pDesc);
 
 		[VtblIndex(1)]
-		ID3D11ShaderReflectionType GetMemberTypeByIndex(uint Index);
+		ID3D11ShaderReflectionType* GetMemberTypeByIndex(uint Index);
 
 		[VtblIndex(2)]
-		ID3D11ShaderReflectionType GetMemberTypeByName(sbyte* Name);
+		ID3D11ShaderReflectionType* GetMemberTypeByName(sbyte* Name);
 
 		[VtblIndex(3)]
 		sbyte* GetMemberTypeName(uint Index);
@@ -196,16 +196,16 @@ public unsafe partial struct ID3D11ShaderReflectionType : ID3D11ShaderReflection
 		HResult IsEqual(ID3D11ShaderReflectionType* pType);
 
 		[VtblIndex(5)]
-		ID3D11ShaderReflectionType GetSubType();
+		ID3D11ShaderReflectionType* GetSubType();
 
 		[VtblIndex(6)]
-		ID3D11ShaderReflectionType GetBaseClass();
+		ID3D11ShaderReflectionType* GetBaseClass();
 
 		[VtblIndex(7)]
 		uint GetNumInterfaces();
 
 		[VtblIndex(8)]
-		ID3D11ShaderReflectionType GetInterfaceByIndex(uint uIndex);
+		ID3D11ShaderReflectionType* GetInterfaceByIndex(uint uIndex);
 
 		[VtblIndex(9)]
 		HResult IsOfType(ID3D11ShaderReflectionType* pType);
diff --git a/src/Vortice.Win32.Graphics.Direct3D11/Generated/ID3D11ShaderReflectionVariable.cs b/src/Vortice.Win32.Graphics.Direct3D11/Generated/ID3D11ShaderReflectionVariable.cs
index 15ae497..3f9cc5a 100644
--- a/src/Vortice.Win32.Graphics.Direct3D11/Generated/ID3D11ShaderReflectionVariable.cs
+++ b/src/Vortice.Win32.Graphics.Direct3D11/Generated/ID3D11ShaderReflectionVariable.cs
@@ -61,24 +61,24 @@ public unsafe partial struct ID3D11ShaderReflectionVariable : ID3D11ShaderReflec
 	/// <include file='../Direct3D11.xml' path='doc/member[@name="ID3D11ShaderReflectionVariable::GetType"]/*' />
 	[MethodImpl(MethodImplOptions.AggressiveInlining)]
 	[VtblIndex(1)]
-	public new ID3D11ShaderReflectionType GetType()
+	public new ID3D11ShaderReflectionType* GetType()
 	{
 #if NET6_0_OR_GREATER
-		return ((delegate* unmanaged<ID3D11ShaderReflectionVariable*, ID3D11ShaderReflectionType>)(lpVtbl[1]))((ID3D11ShaderReflectionVariable*)Unsafe.AsPointer(ref this));
+		return ((delegate* unmanaged<ID3D11ShaderReflectionVariable*, ID3D11ShaderReflectionType*>)(lpVtbl[1]))((ID3D11ShaderReflectionVariable*)Unsafe.AsPointer(ref this));
 #else
-		return ((delegate* unmanaged[Stdcall]<ID3D11ShaderReflectionVariable*, ID3D11ShaderReflectionType>)(lpVtbl[1]))((ID3D11ShaderReflectionVariable*)Unsafe.AsPointer(ref this));
+		return ((delegate* unmanaged[Stdcall]<ID3D11ShaderReflectionVariable*, ID3D11ShaderReflectionType*>)(lpVtbl[1]))((ID3D11ShaderReflectionVariable*)Unsafe.AsPointer(ref this));
 #endif
 	}
 
 	/// <include file='../Direct3D11.xml' path='doc/member[@name="ID3D11ShaderReflectionVariable::GetBuffer"]/*' />
 	[MethodImpl(MethodImplOptions.AggressiveInlining)]
 	[VtblIndex(2)]
-	public ID3D11ShaderReflectionConstantBuffer GetBuffer()
+	public ID3D11ShaderReflectionConstantBuffer* GetBuffer()
 	{
 #if NET6_0_OR_GREATER
-		return ((delegate* unmanaged<ID3D11ShaderReflectionVariable*, ID3D11ShaderReflectionConstantBuffer>)(lpVtbl[2]))((ID3D11ShaderReflectionVariable*)Unsafe.AsPointer(ref this));
+		return ((delegate* unmanaged<ID3D11ShaderReflectionVariable*, ID3D11ShaderReflectionConstantBuffer*>)(lpVtbl[2]))((ID3D11ShaderReflectionVariable*)Unsafe.AsPointer(ref this));
 #else
-		return ((delegate* unmanaged[Stdcall]<ID3D11ShaderReflectionVariable*, ID3D11ShaderReflectionConstantBuffer>)(lpVtbl[2]))((ID3D11ShaderReflectionVariable*)Unsafe.AsPointer(ref this));
+		return ((delegate* unmanaged[Stdcall]<ID3D11ShaderReflectionVariable*, ID3D11ShaderReflectionConstantBuffer*>)(lpVtbl[2]))((ID3D11ShaderReflectionVariable*)Unsafe.AsPointer(ref this));
 #endif
 	}
 
@@ -100,10 +100,10 @@ public unsafe partial struct ID3D11ShaderReflectionVariable : ID3D11ShaderReflec
 		HResult GetDesc(ShaderVariableDescription* pDesc);
 
 		[VtblIndex(1)]
-		ID3D11ShaderReflectionType GetType();
+		ID3D11ShaderReflectionType* GetType();
 
 		[VtblIndex(2)]
-		ID3D11ShaderReflectionConstantBuffer GetBuffer();
+		ID3D11ShaderReflectionConstantBuffer* GetBuffer();
 
 		[VtblIndex(3)]
 		uint GetInterfaceSlot(uint uArrayIndex);
diff --git a/src/Vortice.Win32.Graphics.Direct3D12/Generated/ID3D12FunctionReflection.cs b/src/Vortice.Win32.Graphics.Direct3D12/Generated/ID3D12FunctionReflection.cs
index 60b8ea7..859d711 100644
--- a/src/Vortice.Win32.Graphics.Direct3D12/Generated/ID3D12FunctionReflection.cs
+++ b/src/Vortice.Win32.Graphics.Direct3D12/Generated/ID3D12FunctionReflection.cs
@@ -61,24 +61,24 @@ public unsafe partial struct ID3D12FunctionReflection : ID3D12FunctionReflection
 	/// <include file='../Direct3D12.xml' path='doc/member[@name="ID3D12FunctionReflection::GetConstantBufferByIndex"]/*' />
 	[MethodImpl(MethodImplOptions.AggressiveInlining)]
 	[VtblIndex(1)]
-	public ID3D12ShaderReflectionConstantBuffer GetConstantBufferByIndex(uint BufferIndex)
+	public ID3D12ShaderReflectionConstantBuffer* GetConstantBufferByIndex(uint BufferIndex)
 	{
 #if NET6_0_OR_GREATER
-		return ((delegate* unmanaged<ID3D12FunctionReflection*, uint, ID3D12ShaderReflectionConstantBuffer>)(lpVtbl[1]))((ID3D12FunctionReflection*)Unsafe.AsPointer(ref this), BufferIndex);
+		return ((delegate* unmanaged<ID3D12FunctionReflection*, uint, ID3D12ShaderReflectionConstantBuffer*>)(lpVtbl[1]))((ID3D12FunctionReflection*)Unsafe.AsPointer(ref this), BufferIndex);
 #else
-		return ((delegate* unmanaged[Stdcall]<ID3D12FunctionReflection*, uint, ID3D12ShaderReflectionConstantBuffer>)(lpVtbl[1]))((ID3D12FunctionReflection*)Unsafe.AsPointer(ref this), BufferIndex);
+		return ((delegate* unmanaged[Stdcall]<ID3D12FunctionReflection*, uint, ID3D12ShaderReflectionConstantBuffer*>)(lpVtbl[1]))((ID3D12FunctionReflection*)Unsafe.AsPointer(ref this), BufferIndex);
 #endif
 	}
 
 	/// <include file='../Direct3D12.xml' path='doc/member[@name="ID3D12FunctionReflection::GetConstantBufferByName"]/*' />
 	[MethodImpl(MethodImplOptions.AggressiveInlining)]
 	[VtblIndex(2)]
-	public ID3D12ShaderReflectionConstantBuffer GetConstantBufferByName(sbyte* Name)
+	public ID3D12ShaderReflectionConstantBuffer* GetConstantBufferByName(sbyte* Name)
 	{
 #if NET6_0_OR_GREATER
-		return ((delegate* unmanaged<ID3D12FunctionReflection*, sbyte*, ID3D12ShaderReflectionConstantBuffer>)(lpVtbl[2]))((ID3D12FunctionReflection*)Unsafe.AsPointer(ref this), Name);
+		return ((delegate* unmanaged<ID3D12FunctionReflection*, sbyte*, ID3D12ShaderReflectionConstantBuffer*>)(lpVtbl[2]))((ID3D12FunctionReflection*)Unsafe.AsPointer(ref this), Name);
 #else
-		return ((delegate* unmanaged[Stdcall]<ID3D12FunctionReflection*, sbyte*, ID3D12ShaderReflectionConstantBuffer>)(lpVtbl[2]))((ID3D12FunctionReflection*)Unsafe.AsPointer(ref this), Name);
+		return ((delegate* unmanaged[Stdcall]<ID3D12FunctionReflection*, sbyte*, ID3D12ShaderReflectionConstantBuffer*>)(lpVtbl[2]))((ID3D12FunctionReflection*)Unsafe.AsPointer(ref this), Name);
 #endif
 	}
 
@@ -97,12 +97,12 @@ public unsafe partial struct ID3D12FunctionReflection : ID3D12FunctionReflection
 	/// <include file='../Direct3D12.xml' path='doc/member[@name="ID3D12FunctionReflection::GetVariableByName"]/*' />
 	[MethodImpl(MethodImplOptions.AggressiveInlining)]
 	[VtblIndex(4)]
-	public ID3D12ShaderReflectionVariable GetVariableByName(sbyte* Name)
+	public ID3D12ShaderReflectionVariable* GetVariableByName(sbyte* Name)
 	{
 #if NET6_0_OR_GREATER
-		return ((delegate* unmanaged<ID3D12FunctionReflection*, sbyte*, ID3D12ShaderReflectionVariable>)(lpVtbl[4]))((ID3D12FunctionReflection*)Unsafe.AsPointer(ref this), Name);
+		return ((delegate* unmanaged<ID3D12FunctionReflection*, sbyte*, ID3D12ShaderReflectionVariable*>)(lpVtbl[4]))((ID3D12FunctionReflection*)Unsafe.AsPointer(ref this), Name);
 #else
-		return ((delegate* unmanaged[Stdcall]<ID3D12FunctionReflection*, sbyte*, ID3D12ShaderReflectionVariable>)(lpVtbl[4]))((ID3D12FunctionReflection*)Unsafe.AsPointer(ref this), Name);
+		return ((delegate* unmanaged[Stdcall]<ID3D12FunctionReflection*, sbyte*, ID3D12ShaderReflectionVariable*>)(lpVtbl[4]))((ID3D12FunctionReflection*)Unsafe.AsPointer(ref this), Name);
 #endif
 	}
 
@@ -121,12 +121,12 @@ public unsafe partial struct ID3D12FunctionReflection : ID3D12FunctionReflection
 	/// <include file='../Direct3D12.xml' path='doc/member[@name="ID3D12FunctionReflection::GetFunctionParameter"]/*' />
 	[MethodImpl(MethodImplOptions.AggressiveInlining)]
 	[VtblIndex(6)]
-	public ID3D12FunctionParameterReflection GetFunctionParameter(int ParameterIndex)
+	public ID3D12FunctionParameterReflection* GetFunctionParameter(int ParameterIndex)
 	{
 #if NET6_0_OR_GREATER
-		return ((delegate* unmanaged<ID3D12FunctionReflection*, int, ID3D12FunctionParameterReflection>)(lpVtbl[6]))((ID3D12FunctionReflection*)Unsafe.AsPointer(ref this), ParameterIndex);
+		return ((delegate* unmanaged<ID3D12FunctionReflection*, int, ID3D12FunctionParameterReflection*>)(lpVtbl[6]))((ID3D12FunctionReflection*)Unsafe.AsPointer(ref this), ParameterIndex);
 #else
-		return ((delegate* unmanaged[Stdcall]<ID3D12FunctionReflection*, int, ID3D12FunctionParameterReflection>)(lpVtbl[6]))((ID3D12FunctionReflection*)Unsafe.AsPointer(ref this), ParameterIndex);
+		return ((delegate* unmanaged[Stdcall]<ID3D12FunctionReflection*, int, ID3D12FunctionParameterReflection*>)(lpVtbl[6]))((ID3D12FunctionReflection*)Unsafe.AsPointer(ref this), ParameterIndex);
 #endif
 	}
 
@@ -136,22 +136,22 @@ public unsafe partial struct ID3D12FunctionReflection : ID3D12FunctionReflection
 		HResult GetDesc(FunctionDescription* pDesc);
 
 		[VtblIndex(1)]
-		ID3D12ShaderReflectionConstantBuffer GetConstantBufferByIndex(uint BufferIndex);
+		ID3D12ShaderReflectionConstantBuffer* GetConstantBufferByIndex(uint BufferIndex);
 
 		[VtblIndex(2)]
-		ID3D12ShaderReflectionConstantBuffer GetConstantBufferByName(sbyte* Name);
+		ID3D12ShaderReflectionConstantBuffer* GetConstantBufferByName(sbyte* Name);
 
 		[VtblIndex(3)]
 		HResult GetResourceBindingDesc(uint ResourceIndex, ShaderInputBindDescription* pDesc);
 
 		[VtblIndex(4)]
-		ID3D12ShaderReflectionVariable GetVariableByName(sbyte* Name);
+		ID3D12ShaderReflectionVariable* GetVariableByName(sbyte* Name);
 
 		[VtblIndex(5)]
 		HResult GetResourceBindingDescByName(sbyte* Name, ShaderInputBindDescription* pDesc);
 
 		[VtblIndex(6)]
-		ID3D12FunctionParameterReflection GetFunctionParameter(int ParameterIndex);
+		ID3D12FunctionParameterReflection* GetFunctionParameter(int ParameterIndex);
 	}
 }
 
diff --git a/src/Vortice.Win32.Graphics.Direct3D12/Generated/ID3D12LibraryReflection.cs b/src/Vortice.Win32.Graphics.Direct3D12/Generated/ID3D12LibraryReflection.cs
index 861848f..64da81c 100644
--- a/src/Vortice.Win32.Graphics.Direct3D12/Generated/ID3D12LibraryReflection.cs
+++ b/src/Vortice.Win32.Graphics.Direct3D12/Generated/ID3D12LibraryReflection.cs
@@ -101,12 +101,12 @@ public unsafe partial struct ID3D12LibraryReflection : ID3D12LibraryReflection.I
 	/// <include file='../Direct3D12.xml' path='doc/member[@name="ID3D12LibraryReflection::GetFunctionByIndex"]/*' />
 	[MethodImpl(MethodImplOptions.AggressiveInlining)]
 	[VtblIndex(4)]
-	public ID3D12FunctionReflection GetFunctionByIndex(int FunctionIndex)
+	public ID3D12FunctionReflection* GetFunctionByIndex(int FunctionIndex)
 	{
 #if NET6_0_OR_GREATER
-		return ((delegate* unmanaged<ID3D12LibraryReflection*, int, ID3D12FunctionReflection>)(lpVtbl[4]))((ID3D12LibraryReflection*)Unsafe.AsPointer(ref this), FunctionIndex);
+		return ((delegate* unmanaged<ID3D12LibraryReflection*, int, ID3D12FunctionReflection*>)(lpVtbl[4]))((ID3D12LibraryReflection*)Unsafe.AsPointer(ref this), FunctionIndex);
 #else
-		return ((delegate* unmanaged[Stdcall]<ID3D12LibraryReflection*, int, ID3D12FunctionReflection>)(lpVtbl[4]))((ID3D12LibraryReflection*)Unsafe.AsPointer(ref this), FunctionIndex);
+		return ((delegate* unmanaged[Stdcall]<ID3D12LibraryReflection*, int, ID3D12FunctionReflection*>)(lpVtbl[4]))((ID3D12LibraryReflection*)Unsafe.AsPointer(ref this), FunctionIndex);
 #endif
 	}
 
@@ -116,7 +116,7 @@ public unsafe partial struct ID3D12LibraryReflection : ID3D12LibraryReflection.I
 		HResult GetDesc(LibraryDescription* pDesc);
 
 		[VtblIndex(4)]
-		ID3D12FunctionReflection GetFunctionByIndex(int FunctionIndex);
+		ID3D12FunctionReflection* GetFunctionByIndex(int FunctionIndex);
 	}
 }
 
diff --git a/src/Vortice.Win32.Graphics.Direct3D12/Generated/ID3D12ShaderReflection.cs b/src/Vortice.Win32.Graphics.Direct3D12/Generated/ID3D12ShaderReflection.cs
index a18422b..e463ee2 100644
--- a/src/Vortice.Win32.Graphics.Direct3D12/Generated/ID3D12ShaderReflection.cs
+++ b/src/Vortice.Win32.Graphics.Direct3D12/Generated/ID3D12ShaderReflection.cs
@@ -101,24 +101,24 @@ public unsafe partial struct ID3D12ShaderReflection : ID3D12ShaderReflection.Int
 	/// <include file='../Direct3D12.xml' path='doc/member[@name="ID3D12ShaderReflection::GetConstantBufferByIndex"]/*' />
 	[MethodImpl(MethodImplOptions.AggressiveInlining)]
 	[VtblIndex(4)]
-	public ID3D12ShaderReflectionConstantBuffer GetConstantBufferByIndex(uint Index)
+	public ID3D12ShaderReflectionConstantBuffer* GetConstantBufferByIndex(uint Index)
 	{
 #if NET6_0_OR_GREATER
-		return ((delegate* unmanaged<ID3D12ShaderReflection*, uint, ID3D12ShaderReflectionConstantBuffer>)(lpVtbl[4]))((ID3D12ShaderReflection*)Unsafe.AsPointer(ref this), Index);
+        return ((delegate* unmanaged<ID3D12ShaderReflection*, uint, ID3D12ShaderReflectionConstantBuffer*>)(lpVtbl[4]))((ID3D12ShaderReflection*)Unsafe.AsPointer(ref this), Index);
 #else
-		return ((delegate* unmanaged[Stdcall]<ID3D12ShaderReflection*, uint, ID3D12ShaderReflectionConstantBuffer>)(lpVtbl[4]))((ID3D12ShaderReflection*)Unsafe.AsPointer(ref this), Index);
+		return ((delegate* unmanaged[Stdcall]<ID3D12ShaderReflection*, uint, ID3D12ShaderReflectionConstantBuffer*>)(lpVtbl[4]))((ID3D12ShaderReflection*)Unsafe.AsPointer(ref this), Index);
 #endif
 	}
 
 	/// <include file='../Direct3D12.xml' path='doc/member[@name="ID3D12ShaderReflection::GetConstantBufferByName"]/*' />
 	[MethodImpl(MethodImplOptions.AggressiveInlining)]
 	[VtblIndex(5)]
-	public ID3D12ShaderReflectionConstantBuffer GetConstantBufferByName(sbyte* Name)
+	public ID3D12ShaderReflectionConstantBuffer* GetConstantBufferByName(sbyte* Name)
 	{
 #if NET6_0_OR_GREATER
-		return ((delegate* unmanaged<ID3D12ShaderReflection*, sbyte*, ID3D12ShaderReflectionConstantBuffer>)(lpVtbl[5]))((ID3D12ShaderReflection*)Unsafe.AsPointer(ref this), Name);
+		return ((delegate* unmanaged<ID3D12ShaderReflection*, sbyte*, ID3D12ShaderReflectionConstantBuffer*>)(lpVtbl[5]))((ID3D12ShaderReflection*)Unsafe.AsPointer(ref this), Name);
 #else
-		return ((delegate* unmanaged[Stdcall]<ID3D12ShaderReflection*, sbyte*, ID3D12ShaderReflectionConstantBuffer>)(lpVtbl[5]))((ID3D12ShaderReflection*)Unsafe.AsPointer(ref this), Name);
+		return ((delegate* unmanaged[Stdcall]<ID3D12ShaderReflection*, sbyte*, ID3D12ShaderReflectionConstantBuffer*>)(lpVtbl[5]))((ID3D12ShaderReflection*)Unsafe.AsPointer(ref this), Name);
 #endif
 	}
 
@@ -173,12 +173,12 @@ public unsafe partial struct ID3D12ShaderReflection : ID3D12ShaderReflection.Int
 	/// <include file='../Direct3D12.xml' path='doc/member[@name="ID3D12ShaderReflection::GetVariableByName"]/*' />
 	[MethodImpl(MethodImplOptions.AggressiveInlining)]
 	[VtblIndex(10)]
-	public ID3D12ShaderReflectionVariable GetVariableByName(sbyte* Name)
+	public ID3D12ShaderReflectionVariable* GetVariableByName(sbyte* Name)
 	{
 #if NET6_0_OR_GREATER
-		return ((delegate* unmanaged<ID3D12ShaderReflection*, sbyte*, ID3D12ShaderReflectionVariable>)(lpVtbl[10]))((ID3D12ShaderReflection*)Unsafe.AsPointer(ref this), Name);
+		return ((delegate* unmanaged<ID3D12ShaderReflection*, sbyte*, ID3D12ShaderReflectionVariable*>)(lpVtbl[10]))((ID3D12ShaderReflection*)Unsafe.AsPointer(ref this), Name);
 #else
-		return ((delegate* unmanaged[Stdcall]<ID3D12ShaderReflection*, sbyte*, ID3D12ShaderReflectionVariable>)(lpVtbl[10]))((ID3D12ShaderReflection*)Unsafe.AsPointer(ref this), Name);
+		return ((delegate* unmanaged[Stdcall]<ID3D12ShaderReflection*, sbyte*, ID3D12ShaderReflectionVariable*>)(lpVtbl[10]))((ID3D12ShaderReflection*)Unsafe.AsPointer(ref this), Name);
 #endif
 	}
 
@@ -320,10 +320,10 @@ public unsafe partial struct ID3D12ShaderReflection : ID3D12ShaderReflection.Int
 		HResult GetDesc(ShaderDescription* pDesc);
 
 		[VtblIndex(4)]
-		ID3D12ShaderReflectionConstantBuffer GetConstantBufferByIndex(uint Index);
+		ID3D12ShaderReflectionConstantBuffer* GetConstantBufferByIndex(uint Index);
 
 		[VtblIndex(5)]
-		ID3D12ShaderReflectionConstantBuffer GetConstantBufferByName(sbyte* Name);
+		ID3D12ShaderReflectionConstantBuffer* GetConstantBufferByName(sbyte* Name);
 
 		[VtblIndex(6)]
 		HResult GetResourceBindingDesc(uint ResourceIndex, ShaderInputBindDescription* pDesc);
@@ -338,7 +338,7 @@ public unsafe partial struct ID3D12ShaderReflection : ID3D12ShaderReflection.Int
 		HResult GetPatchConstantParameterDesc(uint ParameterIndex, SignatureParameterDescription* pDesc);
 
 		[VtblIndex(10)]
-		ID3D12ShaderReflectionVariable GetVariableByName(sbyte* Name);
+		ID3D12ShaderReflectionVariable* GetVariableByName(sbyte* Name);
 
 		[VtblIndex(11)]
 		HResult GetResourceBindingDescByName(sbyte* Name, ShaderInputBindDescription* pDesc);
diff --git a/src/Vortice.Win32.Graphics.Direct3D12/Generated/ID3D12ShaderReflectionConstantBuffer.cs b/src/Vortice.Win32.Graphics.Direct3D12/Generated/ID3D12ShaderReflectionConstantBuffer.cs
index 7007ef7..8bfecc7 100644
--- a/src/Vortice.Win32.Graphics.Direct3D12/Generated/ID3D12ShaderReflectionConstantBuffer.cs
+++ b/src/Vortice.Win32.Graphics.Direct3D12/Generated/ID3D12ShaderReflectionConstantBuffer.cs
@@ -61,24 +61,24 @@ public unsafe partial struct ID3D12ShaderReflectionConstantBuffer : ID3D12Shader
 	/// <include file='../Direct3D12.xml' path='doc/member[@name="ID3D12ShaderReflectionConstantBuffer::GetVariableByIndex"]/*' />
 	[MethodImpl(MethodImplOptions.AggressiveInlining)]
 	[VtblIndex(1)]
-	public ID3D12ShaderReflectionVariable GetVariableByIndex(uint Index)
+	public ID3D12ShaderReflectionVariable* GetVariableByIndex(uint Index)
 	{
 #if NET6_0_OR_GREATER
-		return ((delegate* unmanaged<ID3D12ShaderReflectionConstantBuffer*, uint, ID3D12ShaderReflectionVariable>)(lpVtbl[1]))((ID3D12ShaderReflectionConstantBuffer*)Unsafe.AsPointer(ref this), Index);
+		return ((delegate* unmanaged<ID3D12ShaderReflectionConstantBuffer*, uint, ID3D12ShaderReflectionVariable*>)(lpVtbl[1]))((ID3D12ShaderReflectionConstantBuffer*)Unsafe.AsPointer(ref this), Index);
 #else
-		return ((delegate* unmanaged[Stdcall]<ID3D12ShaderReflectionConstantBuffer*, uint, ID3D12ShaderReflectionVariable>)(lpVtbl[1]))((ID3D12ShaderReflectionConstantBuffer*)Unsafe.AsPointer(ref this), Index);
+		return ((delegate* unmanaged[Stdcall]<ID3D12ShaderReflectionConstantBuffer*, uint, ID3D12ShaderReflectionVariable*>)(lpVtbl[1]))((ID3D12ShaderReflectionConstantBuffer*)Unsafe.AsPointer(ref this), Index);
 #endif
 	}
 
 	/// <include file='../Direct3D12.xml' path='doc/member[@name="ID3D12ShaderReflectionConstantBuffer::GetVariableByName"]/*' />
 	[MethodImpl(MethodImplOptions.AggressiveInlining)]
 	[VtblIndex(2)]
-	public ID3D12ShaderReflectionVariable GetVariableByName(sbyte* Name)
+	public ID3D12ShaderReflectionVariable* GetVariableByName(sbyte* Name)
 	{
 #if NET6_0_OR_GREATER
-		return ((delegate* unmanaged<ID3D12ShaderReflectionConstantBuffer*, sbyte*, ID3D12ShaderReflectionVariable>)(lpVtbl[2]))((ID3D12ShaderReflectionConstantBuffer*)Unsafe.AsPointer(ref this), Name);
+		return ((delegate* unmanaged<ID3D12ShaderReflectionConstantBuffer*, sbyte*, ID3D12ShaderReflectionVariable*>)(lpVtbl[2]))((ID3D12ShaderReflectionConstantBuffer*)Unsafe.AsPointer(ref this), Name);
 #else
-		return ((delegate* unmanaged[Stdcall]<ID3D12ShaderReflectionConstantBuffer*, sbyte*, ID3D12ShaderReflectionVariable>)(lpVtbl[2]))((ID3D12ShaderReflectionConstantBuffer*)Unsafe.AsPointer(ref this), Name);
+		return ((delegate* unmanaged[Stdcall]<ID3D12ShaderReflectionConstantBuffer*, sbyte*, ID3D12ShaderReflectionVariable*>)(lpVtbl[2]))((ID3D12ShaderReflectionConstantBuffer*)Unsafe.AsPointer(ref this), Name);
 #endif
 	}
 
@@ -88,10 +88,10 @@ public unsafe partial struct ID3D12ShaderReflectionConstantBuffer : ID3D12Shader
 		HResult GetDesc(ShaderBufferDescription* pDesc);
 
 		[VtblIndex(1)]
-		ID3D12ShaderReflectionVariable GetVariableByIndex(uint Index);
+		ID3D12ShaderReflectionVariable* GetVariableByIndex(uint Index);
 
 		[VtblIndex(2)]
-		ID3D12ShaderReflectionVariable GetVariableByName(sbyte* Name);
+		ID3D12ShaderReflectionVariable* GetVariableByName(sbyte* Name);
 	}
 }
 
diff --git a/src/Vortice.Win32.Graphics.Direct3D12/Generated/ID3D12ShaderReflectionType.cs b/src/Vortice.Win32.Graphics.Direct3D12/Generated/ID3D12ShaderReflectionType.cs
index 9c855a1..db581a7 100644
--- a/src/Vortice.Win32.Graphics.Direct3D12/Generated/ID3D12ShaderReflectionType.cs
+++ b/src/Vortice.Win32.Graphics.Direct3D12/Generated/ID3D12ShaderReflectionType.cs
@@ -61,24 +61,24 @@ public unsafe partial struct ID3D12ShaderReflectionType : ID3D12ShaderReflection
 	/// <include file='../Direct3D12.xml' path='doc/member[@name="ID3D12ShaderReflectionType::GetMemberTypeByIndex"]/*' />
 	[MethodImpl(MethodImplOptions.AggressiveInlining)]
 	[VtblIndex(1)]
-	public ID3D12ShaderReflectionType GetMemberTypeByIndex(uint Index)
+	public ID3D12ShaderReflectionType* GetMemberTypeByIndex(uint Index)
 	{
 #if NET6_0_OR_GREATER
-		return ((delegate* unmanaged<ID3D12ShaderReflectionType*, uint, ID3D12ShaderReflectionType>)(lpVtbl[1]))((ID3D12ShaderReflectionType*)Unsafe.AsPointer(ref this), Index);
+		return ((delegate* unmanaged<ID3D12ShaderReflectionType*, uint, ID3D12ShaderReflectionType*>)(lpVtbl[1]))((ID3D12ShaderReflectionType*)Unsafe.AsPointer(ref this), Index);
 #else
-		return ((delegate* unmanaged[Stdcall]<ID3D12ShaderReflectionType*, uint, ID3D12ShaderReflectionType>)(lpVtbl[1]))((ID3D12ShaderReflectionType*)Unsafe.AsPointer(ref this), Index);
+		return ((delegate* unmanaged[Stdcall]<ID3D12ShaderReflectionType*, uint, ID3D12ShaderReflectionType*>)(lpVtbl[1]))((ID3D12ShaderReflectionType*)Unsafe.AsPointer(ref this), Index);
 #endif
 	}
 
 	/// <include file='../Direct3D12.xml' path='doc/member[@name="ID3D12ShaderReflectionType::GetMemberTypeByName"]/*' />
 	[MethodImpl(MethodImplOptions.AggressiveInlining)]
 	[VtblIndex(2)]
-	public ID3D12ShaderReflectionType GetMemberTypeByName(sbyte* Name)
+	public ID3D12ShaderReflectionType* GetMemberTypeByName(sbyte* Name)
 	{
 #if NET6_0_OR_GREATER
-		return ((delegate* unmanaged<ID3D12ShaderReflectionType*, sbyte*, ID3D12ShaderReflectionType>)(lpVtbl[2]))((ID3D12ShaderReflectionType*)Unsafe.AsPointer(ref this), Name);
+		return ((delegate* unmanaged<ID3D12ShaderReflectionType*, sbyte*, ID3D12ShaderReflectionType*>)(lpVtbl[2]))((ID3D12ShaderReflectionType*)Unsafe.AsPointer(ref this), Name);
 #else
-		return ((delegate* unmanaged[Stdcall]<ID3D12ShaderReflectionType*, sbyte*, ID3D12ShaderReflectionType>)(lpVtbl[2]))((ID3D12ShaderReflectionType*)Unsafe.AsPointer(ref this), Name);
+		return ((delegate* unmanaged[Stdcall]<ID3D12ShaderReflectionType*, sbyte*, ID3D12ShaderReflectionType*>)(lpVtbl[2]))((ID3D12ShaderReflectionType*)Unsafe.AsPointer(ref this), Name);
 #endif
 	}
 
@@ -109,24 +109,24 @@ public unsafe partial struct ID3D12ShaderReflectionType : ID3D12ShaderReflection
 	/// <include file='../Direct3D12.xml' path='doc/member[@name="ID3D12ShaderReflectionType::GetSubType"]/*' />
 	[MethodImpl(MethodImplOptions.AggressiveInlining)]
 	[VtblIndex(5)]
-	public ID3D12ShaderReflectionType GetSubType()
+	public ID3D12ShaderReflectionType* GetSubType()
 	{
 #if NET6_0_OR_GREATER
-		return ((delegate* unmanaged<ID3D12ShaderReflectionType*, ID3D12ShaderReflectionType>)(lpVtbl[5]))((ID3D12ShaderReflectionType*)Unsafe.AsPointer(ref this));
+		return ((delegate* unmanaged<ID3D12ShaderReflectionType*, ID3D12ShaderReflectionType*>)(lpVtbl[5]))((ID3D12ShaderReflectionType*)Unsafe.AsPointer(ref this));
 #else
-		return ((delegate* unmanaged[Stdcall]<ID3D12ShaderReflectionType*, ID3D12ShaderReflectionType>)(lpVtbl[5]))((ID3D12ShaderReflectionType*)Unsafe.AsPointer(ref this));
+		return ((delegate* unmanaged[Stdcall]<ID3D12ShaderReflectionType*, ID3D12ShaderReflectionType*>)(lpVtbl[5]))((ID3D12ShaderReflectionType*)Unsafe.AsPointer(ref this));
 #endif
 	}
 
 	/// <include file='../Direct3D12.xml' path='doc/member[@name="ID3D12ShaderReflectionType::GetBaseClass"]/*' />
 	[MethodImpl(MethodImplOptions.AggressiveInlining)]
 	[VtblIndex(6)]
-	public ID3D12ShaderReflectionType GetBaseClass()
+	public ID3D12ShaderReflectionType* GetBaseClass()
 	{
 #if NET6_0_OR_GREATER
-		return ((delegate* unmanaged<ID3D12ShaderReflectionType*, ID3D12ShaderReflectionType>)(lpVtbl[6]))((ID3D12ShaderReflectionType*)Unsafe.AsPointer(ref this));
+		return ((delegate* unmanaged<ID3D12ShaderReflectionType*, ID3D12ShaderReflectionType*>)(lpVtbl[6]))((ID3D12ShaderReflectionType*)Unsafe.AsPointer(ref this));
 #else
-		return ((delegate* unmanaged[Stdcall]<ID3D12ShaderReflectionType*, ID3D12ShaderReflectionType>)(lpVtbl[6]))((ID3D12ShaderReflectionType*)Unsafe.AsPointer(ref this));
+		return ((delegate* unmanaged[Stdcall]<ID3D12ShaderReflectionType*, ID3D12ShaderReflectionType*>)(lpVtbl[6]))((ID3D12ShaderReflectionType*)Unsafe.AsPointer(ref this));
 #endif
 	}
 
@@ -145,12 +145,12 @@ public unsafe partial struct ID3D12ShaderReflectionType : ID3D12ShaderReflection
 	/// <include file='../Direct3D12.xml' path='doc/member[@name="ID3D12ShaderReflectionType::GetInterfaceByIndex"]/*' />
 	[MethodImpl(MethodImplOptions.AggressiveInlining)]
 	[VtblIndex(8)]
-	public ID3D12ShaderReflectionType GetInterfaceByIndex(uint uIndex)
+	public ID3D12ShaderReflectionType* GetInterfaceByIndex(uint uIndex)
 	{
 #if NET6_0_OR_GREATER
-		return ((delegate* unmanaged<ID3D12ShaderReflectionType*, uint, ID3D12ShaderReflectionType>)(lpVtbl[8]))((ID3D12ShaderReflectionType*)Unsafe.AsPointer(ref this), uIndex);
+		return ((delegate* unmanaged<ID3D12ShaderReflectionType*, uint, ID3D12ShaderReflectionType*>)(lpVtbl[8]))((ID3D12ShaderReflectionType*)Unsafe.AsPointer(ref this), uIndex);
 #else
-		return ((delegate* unmanaged[Stdcall]<ID3D12ShaderReflectionType*, uint, ID3D12ShaderReflectionType>)(lpVtbl[8]))((ID3D12ShaderReflectionType*)Unsafe.AsPointer(ref this), uIndex);
+		return ((delegate* unmanaged[Stdcall]<ID3D12ShaderReflectionType*, uint, ID3D12ShaderReflectionType*>)(lpVtbl[8]))((ID3D12ShaderReflectionType*)Unsafe.AsPointer(ref this), uIndex);
 #endif
 	}
 
@@ -184,10 +184,10 @@ public unsafe partial struct ID3D12ShaderReflectionType : ID3D12ShaderReflection
 		HResult GetDesc(ShaderTypeDescription* pDesc);
 
 		[VtblIndex(1)]
-		ID3D12ShaderReflectionType GetMemberTypeByIndex(uint Index);
+		ID3D12ShaderReflectionType* GetMemberTypeByIndex(uint Index);
 
 		[VtblIndex(2)]
-		ID3D12ShaderReflectionType GetMemberTypeByName(sbyte* Name);
+		ID3D12ShaderReflectionType* GetMemberTypeByName(sbyte* Name);
 
 		[VtblIndex(3)]
 		sbyte* GetMemberTypeName(uint Index);
@@ -196,16 +196,16 @@ public unsafe partial struct ID3D12ShaderReflectionType : ID3D12ShaderReflection
 		HResult IsEqual(ID3D12ShaderReflectionType* pType);
 
 		[VtblIndex(5)]
-		ID3D12ShaderReflectionType GetSubType();
+		ID3D12ShaderReflectionType* GetSubType();
 
 		[VtblIndex(6)]
-		ID3D12ShaderReflectionType GetBaseClass();
+		ID3D12ShaderReflectionType* GetBaseClass();
 
 		[VtblIndex(7)]
 		uint GetNumInterfaces();
 
 		[VtblIndex(8)]
-		ID3D12ShaderReflectionType GetInterfaceByIndex(uint uIndex);
+		ID3D12ShaderReflectionType* GetInterfaceByIndex(uint uIndex);
 
 		[VtblIndex(9)]
 		HResult IsOfType(ID3D12ShaderReflectionType* pType);
diff --git a/src/Vortice.Win32.Graphics.Direct3D12/Generated/ID3D12ShaderReflectionVariable.cs b/src/Vortice.Win32.Graphics.Direct3D12/Generated/ID3D12ShaderReflectionVariable.cs
index 72050b0..663ea05 100644
--- a/src/Vortice.Win32.Graphics.Direct3D12/Generated/ID3D12ShaderReflectionVariable.cs
+++ b/src/Vortice.Win32.Graphics.Direct3D12/Generated/ID3D12ShaderReflectionVariable.cs
@@ -61,24 +61,24 @@ public unsafe partial struct ID3D12ShaderReflectionVariable : ID3D12ShaderReflec
 	/// <include file='../Direct3D12.xml' path='doc/member[@name="ID3D12ShaderReflectionVariable::GetType"]/*' />
 	[MethodImpl(MethodImplOptions.AggressiveInlining)]
 	[VtblIndex(1)]
-	public new ID3D12ShaderReflectionType GetType()
+	public new ID3D12ShaderReflectionType* GetType()
 	{
 #if NET6_0_OR_GREATER
-		return ((delegate* unmanaged<ID3D12ShaderReflectionVariable*, ID3D12ShaderReflectionType>)(lpVtbl[1]))((ID3D12ShaderReflectionVariable*)Unsafe.AsPointer(ref this));
+		return ((delegate* unmanaged<ID3D12ShaderReflectionVariable*, ID3D12ShaderReflectionType*>)(lpVtbl[1]))((ID3D12ShaderReflectionVariable*)Unsafe.AsPointer(ref this));
 #else
-		return ((delegate* unmanaged[Stdcall]<ID3D12ShaderReflectionVariable*, ID3D12ShaderReflectionType>)(lpVtbl[1]))((ID3D12ShaderReflectionVariable*)Unsafe.AsPointer(ref this));
+		return ((delegate* unmanaged[Stdcall]<ID3D12ShaderReflectionVariable*, ID3D12ShaderReflectionType*>)(lpVtbl[1]))((ID3D12ShaderReflectionVariable*)Unsafe.AsPointer(ref this));
 #endif
 	}
 
 	/// <include file='../Direct3D12.xml' path='doc/member[@name="ID3D12ShaderReflectionVariable::GetBuffer"]/*' />
 	[MethodImpl(MethodImplOptions.AggressiveInlining)]
 	[VtblIndex(2)]
-	public ID3D12ShaderReflectionConstantBuffer GetBuffer()
+	public ID3D12ShaderReflectionConstantBuffer* GetBuffer()
 	{
 #if NET6_0_OR_GREATER
-		return ((delegate* unmanaged<ID3D12ShaderReflectionVariable*, ID3D12ShaderReflectionConstantBuffer>)(lpVtbl[2]))((ID3D12ShaderReflectionVariable*)Unsafe.AsPointer(ref this));
+		return ((delegate* unmanaged<ID3D12ShaderReflectionVariable*, ID3D12ShaderReflectionConstantBuffer*>)(lpVtbl[2]))((ID3D12ShaderReflectionVariable*)Unsafe.AsPointer(ref this));
 #else
-		return ((delegate* unmanaged[Stdcall]<ID3D12ShaderReflectionVariable*, ID3D12ShaderReflectionConstantBuffer>)(lpVtbl[2]))((ID3D12ShaderReflectionVariable*)Unsafe.AsPointer(ref this));
+		return ((delegate* unmanaged[Stdcall]<ID3D12ShaderReflectionVariable*, ID3D12ShaderReflectionConstantBuffer*>)(lpVtbl[2]))((ID3D12ShaderReflectionVariable*)Unsafe.AsPointer(ref this));
 #endif
 	}
 
@@ -100,10 +100,10 @@ public unsafe partial struct ID3D12ShaderReflectionVariable : ID3D12ShaderReflec
 		HResult GetDesc(ShaderVariableDescription* pDesc);
 
 		[VtblIndex(1)]
-		ID3D12ShaderReflectionType GetType();
+		ID3D12ShaderReflectionType* GetType();
 
 		[VtblIndex(2)]
-		ID3D12ShaderReflectionConstantBuffer GetBuffer();
+		ID3D12ShaderReflectionConstantBuffer* GetBuffer();
 
 		[VtblIndex(3)]
 		uint GetInterfaceSlot(uint uArrayIndex);